Update video_service.py

video_service.py

@@ -1,6 +1,5 @@
 # video_service.py
 
-# --- 1. IMPORTAÇÕES ---
 import torch
 import numpy as np
 import random
@@ -9,15 +8,15 @@ import yaml
 from pathlib import Path
 import imageio
 import tempfile
-from huggingface_hub import hf_hub_download
 import sys
 import subprocess
-from PIL import Image
+import threading
+import time
+from huggingface_hub import hf_hub_download
 
-# --- 2. GERENCIAMENTO DE DEPENDÊNCIAS E SETUP ---
+# --- LÓGICA DE SETUP E DEPENDÊNCIAS ---
 
 def run_setup():
-    """Executa o script setup.py para clonar as dependências necessárias."""
     setup_script_path = "setup.py"
     if not os.path.exists(setup_script_path):
         print("AVISO: script 'setup.py' não encontrado. Pulando a clonagem de dependências.")
@@ -36,7 +35,6 @@ if not LTX_VIDEO_REPO_DIR.exists():
     run_setup()
 
 def add_deps_to_path():
-    """Adiciona o repositório clonado ao sys.path para que suas bibliotecas possam ser importadas."""
     if not LTX_VIDEO_REPO_DIR.exists():
         raise FileNotFoundError(f"Repositório LTX-Video não encontrado em '{LTX_VIDEO_REPO_DIR}'. Execute o setup.")
     if str(LTX_VIDEO_REPO_DIR.resolve()) not in sys.path:
@@ -44,252 +42,221 @@ def add_deps_to_path():
 
 add_deps_to_path()
 
-# --- 3. IMPORTAÇÕES ESPECÍFICAS DO MODELO ---
+# Importações específicas do modelo
 from inference import (
     create_ltx_video_pipeline, create_latent_upsampler,
     load_image_to_tensor_with_resize_and_crop, seed_everething,
     calculate_padding, load_media_file
 )
-from ltx_video.pipelines.pipeline_ltx_video import ConditioningItem, LTXMultiScalePipeline
+from ltx_video.pipelines.pipeline_ltx_video import ConditioningItem
 from ltx_video.utils.skip_layer_strategy import SkipLayerStrategy
 
-# --- 4. FUNÇÕES HELPER DE LOG ---
-def log_tensor_info(tensor, name="Tensor"):
-    if not isinstance(tensor, torch.Tensor):
-        print(f"\n[INFO] O item '{name}' não é um tensor para logar.")
-        return
-    print(f"\n--- Informações do Tensor: {name} ---")
-    print(f"  - Shape: {tensor.shape}")
-    print(f"  - Dtype: {tensor.dtype}")
-    print(f"  - Device: {tensor.device}")
-    if tensor.numel() > 0:
-        print(f"  - Min valor: {tensor.min().item():.4f}")
-        print(f"  - Max valor: {tensor.max().item():.4f}")
-        print(f"  - Média: {tensor.mean().item():.4f}")
-    else:
-        print("  - O tensor está vazio, sem estatísticas.")
-    print("------------------------------------------\n")
+# --- CONFIGURAÇÃO DA DISTRIBUIÇÃO DE GPUS ---
+GPU_MAPPING = [
+    {'base': 'cuda:0', 'upscaler': 'cuda:2'},
+    {'base': 'cuda:1', 'upscaler': 'cuda:3'}
+]
 
-# --- 5. CLASSE PRINCIPAL DO SERVIÇO ---
 class VideoService:
     def __init__(self):
-        print("Inicializando VideoService...")
+        print("Inicializando VideoService (modo Lazy Loading)...")
+        self.models_loaded = False
+        self.workers = None
         self.config = self._load_config()
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        self.last_memory_reserved_mb = 0
-        self.pipeline, self.latent_upsampler = self._load_models()
-        print(f"Movendo modelos para o dispositivo de inferência: {self.device}")
-        self.pipeline.to(self.device)
-        if self.latent_upsampler:
-            self.latent_upsampler.to(self.device)
-        if self.device == "cuda":
-            torch.cuda.empty_cache()
-            self._log_gpu_memory("Após carregar modelos")
-        print("VideoService pronto para uso.")
+        self.models_dir = "downloaded_models"
+        self.loading_lock = threading.Lock() # Para evitar que múltiplos usuários iniciem o carregamento ao mesmo tempo
 
-    def _log_gpu_memory(self, stage_name: str):
-        if self.device != "cuda": return
-        current_reserved_b = torch.cuda.memory_reserved()
-        current_reserved_mb = current_reserved_b / (1024 ** 2)
-        total_memory_b = torch.cuda.get_device_properties(0).total_memory
-        total_memory_mb = total_memory_b / (1024 ** 2)
-        peak_reserved_mb = torch.cuda.max_memory_reserved() / (1024 ** 2)
-        delta_mb = current_reserved_mb - self.last_memory_reserved_mb
-        print(f"\n--- [LOG DE MEMÓRIA GPU] - {stage_name} ---")
-        print(f"  - Uso Atual (Reservado): {current_reserved_mb:.2f} MB / {total_memory_mb:.2f} MB")
-        print(f"  - Variação desde o último log: {delta_mb:+.2f} MB")
-        if peak_reserved_mb > self.last_memory_reserved_mb:
-            print(f"  - Pico de Uso (nesta operação): {peak_reserved_mb:.2f} MB")
-        print("--------------------------------------------------\n")
-        self.last_memory_reserved_mb = current_reserved_mb
+    def _ensure_models_are_loaded(self):
+        """Verifica se os modelos estão carregados e os carrega se não estiverem."""
+        with self.loading_lock:
+            if not self.models_loaded:
+                print("Primeira requisição recebida. Iniciando carregamento dos modelos...")
+                if torch.cuda.is_available() and torch.cuda.device_count() < 4:
+                    raise RuntimeError(f"Este serviço está configurado para 4 GPUs, mas apenas {torch.cuda.device_count()} foram encontradas.")
+                
+                self._download_model_files()
+                self.workers = self._initialize_workers()
+                self.models_loaded = True
+                print(f"Modelos carregados com sucesso. {len(self.workers)} workers prontos.")
 
     def _load_config(self):
         config_file_path = LTX_VIDEO_REPO_DIR / "configs" / "ltxv-13b-0.9.8-distilled.yaml"
         with open(config_file_path, "r") as file:
             return yaml.safe_load(file)
 
-    def _load_models(self):
-        models_dir = "downloaded_models_gradio"
-        Path(models_dir).mkdir(parents=True, exist_ok=True)
+    def _download_model_files(self):
+        Path(self.models_dir).mkdir(parents=True, exist_ok=True)
         LTX_REPO = "Lightricks/LTX-Video"
-        distilled_model_path = hf_hub_download(repo_id=LTX_REPO, filename=self.config["checkpoint_path"], local_dir=models_dir, local_dir_use_symlinks=False)
-        self.config["checkpoint_path"] = distilled_model_path
-        spatial_upscaler_path = hf_hub_download(repo_id=LTX_REPO, filename=self.config["spatial_upscaler_model_path"], local_dir=models_dir, local_dir_use_symlinks=False)
-        self.config["spatial_upscaler_model_path"] = spatial_upscaler_path
-        pipeline = create_ltx_video_pipeline(ckpt_path=self.config["checkpoint_path"], precision=self.config["precision"], text_encoder_model_name_or_path=self.config["text_encoder_model_name_or_path"], sampler=self.config["sampler"], device="cpu", enhance_prompt=False, prompt_enhancer_image_caption_model_name_or_path=self.config["prompt_enhancer_image_caption_model_name_or_path"], prompt_enhancer_llm_model_name_or_path=self.config["prompt_enhancer_llm_model_name_or_path"])
-        latent_upsampler = None
-        if self.config.get("spatial_upscaler_model_path"):
-            latent_upsampler = create_latent_upsampler(self.config["spatial_upscaler_model_path"], device="cpu")
-        return pipeline, latent_upsampler
-        
-    def _prepare_conditioning_tensor_from_file(self, filepath, height, width, padding_values):
-        """Prepara um tensor de condicionamento a partir de um arquivo de imagem."""
-        tensor = load_image_to_tensor_with_resize_and_crop(filepath, height, width)
-        tensor = torch.nn.functional.pad(tensor, padding_values)
-        return tensor.to(self.device)
+        print("Baixando arquivos de modelo (se necessário)...")
+        self.distilled_model_path = hf_hub_download(repo_id=LTX_REPO, filename=self.config["checkpoint_path"], local_dir=self.models_dir)
+        self.spatial_upscaler_path = hf_hub_download(repo_id=LTX_REPO, filename=self.config["spatial_upscaler_model_path"], local_dir=self.models_dir)
+        print("Download de modelos concluído.")
 
-    def _extract_frames_from_video(self, video_path: str, frame_indices: list) -> list:
-        print(f"[INFO] Extraindo frames nos índices: {frame_indices} do vídeo '{video_path}'")
-        extracted_frames = []
-        indices_to_get = set(frame_indices)
-        try:
-            with imageio.get_reader(video_path) as reader:
-                for i, frame in enumerate(reader):
-                    if i in indices_to_get:
-                        extracted_frames.append(frame)
-                    if len(extracted_frames) == len(indices_to_get):
-                        break
-            if len(extracted_frames) != len(frame_indices):
-                print(f"[AVISO] Esperava extrair {len(frame_indices)} frames, mas o vídeo só tinha {len(extracted_frames)} correspondentes.")
-        except Exception as e:
-            print(f"[ERRO] Falha ao extrair frames do vídeo: {e}")
-        return extracted_frames
-    
-    def _get_video_dimensions(self, video_path: str) -> tuple[int, int]:
-        """Lê um arquivo de vídeo e retorna sua largura e altura."""
-        try:
-            with imageio.get_reader(video_path) as reader:
-                meta = reader.get_meta_data()
-                size = meta.get('size')
-                if size:
-                    return size
-            return (None, None)
-        except Exception as e:
-            print(f"[ERRO] Não foi possível ler as dimensões do vídeo: {e}")
-            return (None, None)
-
-    def generate(self, prompt, negative_prompt, mode="text-to-video",
-                 start_image_filepath=None,
-                 middle_image_filepath=None, middle_frame_number=None, middle_image_weight=1.0,
-                 end_image_filepath=None, end_image_weight=1.0,
-                 input_video_filepath=None, height=512, width=704, duration=2.0,
-                 frames_to_use=9, seed=42, randomize_seed=True, guidance_scale=3.0,
-                 improve_texture=True, progress_callback=None):
-        if self.device == "cuda":
-            torch.cuda.empty_cache()
-            torch.cuda.reset_peak_memory_stats()
-        self._log_gpu_memory("Início da Geração")
+    def _load_models_for_worker(self, base_device, upscaler_device):
+        print(f"Carregando modelo base para {base_device} e upscaler para {upscaler_device}")
+        pipeline = create_ltx_video_pipeline(
+            ckpt_path=self.distilled_model_path, precision=self.config["precision"],
+            text_encoder_model_name_or_path=self.config["text_encoder_model_name_or_path"],
+            sampler=self.config["sampler"], device="cpu", enhance_prompt=False,
+            prompt_enhancer_image_caption_model_name_or_path=self.config["prompt_enhancer_image_caption_model_name_or_path"],
+            prompt_enhancer_llm_model_name_or_path=self.config["prompt_enhancer_llm_model_name_or_path"],
+        )
+        latent_upsampler = create_latent_upsampler(self.spatial_upscaler_path, device="cpu")
+        pipeline.to(base_device)
+        latent_upsampler.to(upscaler_device)
+        return pipeline, latent_upsampler
 
-        if mode == "image-to-video" and not start_image_filepath:
-            raise ValueError("A imagem de início é obrigatória para o modo image-to-video")
-        if mode == "video-to-video" and not input_video_filepath:
-            raise ValueError("O vídeo de entrada é obrigatório para o modo video-to-video")
+    def _initialize_workers(self):
+        workers = []
+        for i, mapping in enumerate(GPU_MAPPING):
+            print(f"--- Inicializando Worker {i} ---")
+            pipeline, latent_upsampler = self._load_models_for_worker(mapping['base'], mapping['upscaler'])
+            workers.append({"id": i, "base_pipeline": pipeline, "latent_upsampler": latent_upsampler, "devices": mapping, "lock": threading.Lock()})
+        return workers
 
-        used_seed = random.randint(0, 2**32 - 1) if randomize_seed else int(seed)
-        seed_everething(used_seed)
+    def _acquire_worker(self):
+        while True:
+            for worker in self.workers:
+                if worker["lock"].acquire(blocking=False):
+                    print(f"Worker {worker['id']} adquirido para uma nova tarefa.")
+                    return worker
+            time.sleep(0.1)
 
-        if mode == "video-to-video":
-            orig_w, orig_h = self._get_video_dimensions(input_video_filepath)
-            if orig_w and orig_h:
-                width = round(orig_w / 32) * 32
-                height = round(orig_h / 32) * 32
-                print(f"[INFO] Modo video-to-video: Dimensões recalculadas para {width}x{height}")
-        
-        FPS = 24.0
-        MAX_NUM_FRAMES = 257
-        target_frames_rounded = round(duration * FPS)
-        n_val = round((float(target_frames_rounded) - 1.0) / 8.0)
-        actual_num_frames = max(9, min(MAX_NUM_FRAMES, int(n_val * 8 + 1)))
-        
-        height_padded = ((height - 1) // 32 + 1) * 32
-        width_padded = ((width - 1) // 32 + 1) * 32
-        padding_values = calculate_padding(height, width, height_padded, width_padded)
-        
-        generator = torch.Generator(device=self.device).manual_seed(used_seed)
+    def generate(self, prompt, negative_prompt, input_image_filepath=None, input_video_filepath=None,
+                 height=512, width=704, mode="text-to-video", duration=2.0,
+                 frames_to_use=9, seed=42, randomize_seed=True, guidance_scale=1.0, # Ignorado, mas mantido por compatibilidade
+                 improve_texture=True, progress_callback=None):
         
-        conditioning_items = []
+        # A MÁGICA DO LAZY LOADING ACONTECE AQUI
+        self._ensure_models_are_loaded()
         
-        if mode == "image-to-video":
-            start_tensor = self._prepare_conditioning_tensor_from_file(start_image_filepath, height, width, padding_values)
-            conditioning_items.append(ConditioningItem(start_tensor, 0, 1.0))
-            if middle_image_filepath and middle_frame_number is not None:
-                middle_tensor = self._prepare_conditioning_tensor_from_file(middle_image_filepath, height, width, padding_values)
-                safe_middle_frame = max(0, min(int(middle_frame_number), actual_num_frames - 1))
-                conditioning_items.append(ConditioningItem(middle_tensor, safe_middle_frame, float(middle_image_weight)))
-            if end_image_filepath:
-                end_tensor = self._prepare_conditioning_tensor_from_file(end_image_filepath, height, width, padding_values)
-                last_frame_index = actual_num_frames - 1
-                conditioning_items.append(ConditioningItem(end_tensor, last_frame_index, float(end_image_weight)))
+        worker = self._acquire_worker()
+        base_device = worker['devices']['base']
+        upscaler_device = worker['devices']['upscaler']
         
-        # --- <LÓGICA CORRIGIDA E SIMPLIFICADA> ---
-        elif mode == "video-to-video":
-            indices_to_extract = list(range(0, int(frames_to_use), 8))
-            extracted_frames_np = self._extract_frames_from_video(input_video_filepath, indices_to_extract)
-            x=1
-            with tempfile.TemporaryDirectory() as temp_dir:
-                for i, frame_np in enumerate(extracted_frames_np):
-                    x = x+1
-                    frame_index = indices_to_extract[i]
-                    temp_frame_path = os.path.join(temp_dir, f"frame_{frame_index}.png")
-                    imageio.imwrite(temp_frame_path, frame_np)
-                    
-                    # Reutiliza a função de processamento de imagem, como você sugeriu
-                    frame_tensor = self._prepare_conditioning_tensor_from_file(
-                        temp_frame_path, height, width, padding_values
-                    )
-                    conditioning_items.append(ConditioningItem(frame_tensor, ((x*8)-8)-1, 0.5))
-            print(f"[INFO] {len(conditioning_items)} frames do vídeo foram processados como keyframes de condicionamento.")
+        try:
+            # ... (todo o resto do código da função generate permanece exatamente o mesmo) ...
+            if mode == "image-to-video" and not input_image_filepath: raise ValueError("Caminho da imagem é obrigatório para o modo image-to-video")
+            if mode == "video-to-video" and not input_video_filepath: raise ValueError("Caminho do vídeo é obrigatório para o modo video-to-video")
 
-        call_kwargs = {
-            "prompt": prompt, "negative_prompt": negative_prompt, "height": height_padded, "width": width_padded,
-            "num_frames": actual_num_frames, "frame_rate": int(FPS), "generator": generator, "output_type": "pt",
-            "conditioning_items": conditioning_items if conditioning_items else None, 
-            "media_items": None,
-            "decode_timestep": self.config["decode_timestep"], "decode_noise_scale": self.config["decode_noise_scale"],
-            "stochastic_sampling": True, #self.config["stochastic_sampling"], "image_cond_noise_scale": 0.15,
-            "is_video": False, "vae_per_channel_normalize": True,
-            "mixed_precision": True, #(self.config["precision"] == "mixed_precision"),
-            "offload_to_cpu": False, "enhance_prompt": False,
-            "skip_layer_strategy": None, #$/#SkipLayerStrategy.AttentionValues
-        }
+            used_seed = random.randint(0, 2**32 - 1) if randomize_seed else int(seed)
+            seed_everething(used_seed)
 
-        result_tensor = None
-        if improve_texture:
-            if not self.latent_upsampler:
-                raise ValueError("Upscaler espacial não carregado.")
-            multi_scale_pipeline = LTXMultiScalePipeline(self.pipeline, self.latent_upsampler)
-            first_pass_args = self.config.get("first_pass", {}).copy()
-            first_pass_args["guidance_scale"] = float(guidance_scale)
-            second_pass_args = self.config.get("second_pass", {}).copy()
-            second_pass_args["guidance_scale"] = float(guidance_scale)
-            multi_scale_call_kwargs = call_kwargs.copy()
-            multi_scale_call_kwargs.update({"downscale_factor": self.config["downscale_factor"], "first_pass": first_pass_args, "second_pass": second_pass_args})
-            result_tensor = multi_scale_pipeline(**multi_scale_call_kwargs).images
-            log_tensor_info(result_tensor, "Resultado da Etapa 2 (Saída do Pipeline Multi-Scale)")
-        else:
-            single_pass_kwargs = call_kwargs.copy()
-            first_pass_config = self.config.get("first_pass", {})
-            single_pass_kwargs.update({
-                "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"),
-                "timesteps": first_pass_config.get("timesteps"),
-            })
+            FPS = 24.0; MAX_NUM_FRAMES = 257
+            target_frames_rounded = round(duration * FPS)
+            n_val = round((float(target_frames_rounded) - 1.0) / 8.0)
+            actual_num_frames = max(9, min(MAX_NUM_FRAMES, int(n_val * 8 + 1)))
             
-            print("\n[INFO] Executando pipeline de etapa única...")
-            result_tensor = self.pipeline(**single_pass_kwargs).images
-        
-        pad_left, pad_right, pad_top, pad_bottom = padding_values
-        slice_h_end = -pad_bottom if pad_bottom > 0 else None
-        slice_w_end = -pad_right if pad_right > 0 else None
-        
-        result_tensor = result_tensor[:, :, :actual_num_frames, pad_top:slice_h_end, pad_left:slice_w_end]
-        log_tensor_info(result_tensor, "Tensor Final (Após Pós-processamento, Antes de Salvar)")
+            height_padded = ((height - 1) // 32 + 1) * 32
+            width_padded = ((width - 1) // 32 + 1) * 32
+            padding_values = calculate_padding(height, width, height_padded, width_padded)
+            pad_left, pad_right, pad_top, pad_bottom = padding_values
+            
+            call_kwargs_base = {
+                "prompt": prompt, "negative_prompt": negative_prompt, "num_frames": actual_num_frames, "frame_rate": int(FPS),
+                "decode_timestep": 0.05, "decode_noise_scale": self.config["decode_noise_scale"],
+                "stochastic_sampling": self.config["stochastic_sampling"], "image_cond_noise_scale": 0.025,
+                "is_video": True, "vae_per_channel_normalize": True, "mixed_precision": (self.config["precision"] == "mixed_precision"),
+                "offload_to_cpu": False, "enhance_prompt": False, "skip_layer_strategy": SkipLayerStrategy.AttentionValues
+            }
 
-        video_np = (result_tensor[0].permute(1, 2, 3, 0).cpu().float().numpy() * 255).astype(np.uint8)
-        temp_dir = tempfile.mkdtemp()
-        output_video_path = os.path.join(temp_dir, f"output_{used_seed}.mp4")
+            result_tensor = None
+            if improve_texture:
+                downscale_factor = self.config.get("downscale_factor", 0.5)
+                downscaled_height_ideal = int(height_padded * downscale_factor); downscaled_width_ideal = int(width_padded * downscale_factor)
+                downscaled_height = ((downscaled_height_ideal - 1) // 32 + 1) * 32; downscaled_width = ((downscaled_width_ideal - 1) // 32 + 1) * 32
 
-        with imageio.get_writer(output_video_path, fps=call_kwargs["frame_rate"], codec='libx264', quality=8) as writer:
-            total_frames = len(video_np)
-            for i, frame in enumerate(video_np):
-                writer.append_data(frame)
-                if progress_callback:
-                    progress_callback(i + 1, total_frames)
-        
-        self._log_gpu_memory("Fim da Geração")
-        return output_video_path, used_seed
+                # --- PASSE 1 ---
+                first_pass_kwargs = call_kwargs_base.copy()
+                first_pass_kwargs.update({
+                    "height": downscaled_height, "width": downscaled_width,
+                    "generator": torch.Generator(device=base_device).manual_seed(used_seed),
+                    "output_type": "latent", "guidance_scale": 1.0,
+                    "timesteps": self.config["first_pass"]["timesteps"],
+                    "stg_scale": self.config["first_pass"]["stg_scale"],
+                    "rescaling_scale": self.config["first_pass"]["rescaling_scale"],
+                    "skip_block_list": self.config["first_pass"]["skip_block_list"]
+                })
+
+                if mode == "image-to-video":
+                    padding_low_res = calculate_padding(downscaled_height, downscaled_width, downscaled_height, downscaled_width)
+                    media_tensor_low_res = load_image_to_tensor_with_resize_and_crop(input_image_filepath, downscaled_height, downscaled_width)
+                    media_tensor_low_res = torch.nn.functional.pad(media_tensor_low_res, padding_low_res)
+                    first_pass_kwargs["conditioning_items"] = [ConditioningItem(media_tensor_low_res.to(base_device), 0, 1.0)]
+
+                print(f"Worker {worker['id']}: Iniciando passe 1 em {base_device}")
+                with torch.no_grad(): low_res_latents = worker['base_pipeline'](**first_pass_kwargs).images
+                
+                low_res_latents = low_res_latents.to(upscaler_device)
+                with torch.no_grad(): high_res_latents = worker['latent_upsampler'](low_res_latents)
+                high_res_latents = high_res_latents.to(base_device)
+                
+                # --- PASSE 2 ---
+                second_pass_kwargs = call_kwargs_base.copy()
+                high_res_h, high_res_w = downscaled_height * 2, downscaled_width * 2
+                second_pass_kwargs.update({
+                    "height": high_res_h, "width": high_res_w, "latents": high_res_latents,
+                    "generator": torch.Generator(device=base_device).manual_seed(used_seed),
+                    "output_type": "pt", "image_cond_noise_scale": 0.0, "guidance_scale": 1.0,
+                    "timesteps": self.config["second_pass"]["timesteps"],
+                    "stg_scale": self.config["second_pass"]["stg_scale"],
+                    "rescaling_scale": self.config["second_pass"]["rescaling_scale"],
+                    "skip_block_list": self.config["second_pass"]["skip_block_list"],
+                    "tone_map_compression_ratio": self.config["second_pass"].get("tone_map_compression_ratio", 0.0)
+                })
+                
+                if mode == "image-to-video":
+                    padding_high_res = calculate_padding(high_res_h, high_res_w, high_res_h, high_res_w)
+                    media_tensor_high_res = load_image_to_tensor_with_resize_and_crop(input_image_filepath, high_res_h, high_res_w)
+                    media_tensor_high_res = torch.nn.functional.pad(media_tensor_high_res, padding_high_res)
+                    second_pass_kwargs["conditioning_items"] = [ConditioningItem(media_tensor_high_res.to(base_device), 0, 1.0)]
+
+                print(f"Worker {worker['id']}: Iniciando passe 2 em {base_device}")
+                with torch.no_grad(): result_tensor = worker['base_pipeline'](**second_pass_kwargs).images
+
+            else: # Passe Único
+                single_pass_kwargs = call_kwargs_base.copy()
+                first_pass_config = self.config["first_pass"]
+                single_pass_kwargs.update({
+                    "height": height_padded, "width": width_padded, "output_type": "pt",
+                    "generator": torch.Generator(device=base_device).manual_seed(used_seed),
+                    "guidance_scale": 1.0, **first_pass_config
+                })
+                if mode == "image-to-video":
+                    media_tensor_final = load_image_to_tensor_with_resize_and_crop(input_image_filepath, height_padded, width_padded)
+                    media_tensor_final = torch.nn.functional.pad(media_tensor_final, padding_values)
+                    single_pass_kwargs["conditioning_items"] = [ConditioningItem(media_tensor_final.to(base_device), 0, 1.0)]
+                elif mode == "video-to-video":
+                    single_pass_kwargs["media_items"] = load_media_file(media_path=input_video_filepath, height=height_padded, width=width_padded, max_frames=int(frames_to_use), padding=padding_values).to(base_device)
+                
+                print(f"Worker {worker['id']}: Iniciando passe único em {base_device}")
+                with torch.no_grad(): result_tensor = worker['base_pipeline'](**single_pass_kwargs).images
+            
+            if result_tensor.shape[-2:] != (height, width):
+                num_frames_final = result_tensor.shape[2]
+                videos_tensor = result_tensor.permute(0, 2, 1, 3, 4).reshape(-1, result_tensor.shape[1], result_tensor.shape[3], result_tensor.shape[4])
+                videos_resized = torch.nn.functional.interpolate(videos_tensor, size=(height, width), mode='bilinear', align_corners=False)
+                result_tensor = videos_resized.reshape(result_tensor.shape[0], num_frames_final, result_tensor.shape[1], height, width).permute(0, 2, 1, 3, 4)
+
+            result_tensor = result_tensor[:, :, :actual_num_frames, (pad_top if pad_top > 0 else None):(-pad_bottom if pad_bottom > 0 else None), (pad_left if pad_left > 0 else None):(-pad_right if pad_right > 0 else None)]
+            video_np = (result_tensor[0].permute(1, 2, 3, 0).cpu().float().numpy() * 255).astype(np.uint8)
+            temp_dir = tempfile.mkdtemp()
+            output_video_path = os.path.join(temp_dir, f"output_{used_seed}.mp4")
+
+            with imageio.get_writer(output_video_path, fps=call_kwargs_base["frame_rate"], codec='libx264', quality=8) as writer:
+                for i, frame in enumerate(video_np):
+                    writer.append_data(frame)
+                    if progress_callback: progress_callback(i + 1, len(video_np))
+            return output_video_path, used_seed
+
+        except Exception as e:
+            print(f"!!!!!!!! ERRO no Worker {worker['id']} !!!!!!!!\n{e}")
+            raise e
+        finally:
+            print(f"Worker {worker['id']}: Tarefa finalizada. Limpando cache e liberando worker...")
+            with torch.cuda.device(base_device): torch.cuda.empty_cache()
+            with torch.cuda.device(upscaler_device): torch.cuda.empty_cache()
+            worker["lock"].release()
 
-print("Criando instância do VideoService. O carregamento do modelo começará agora...")
+# A instância do serviço é criada aqui, mas os modelos só serão carregados no primeiro clique.
 video_generation_service = VideoService()