Upload 4 files

api/aduc_ltx_latent_patch.py

@@ -0,0 +1,268 @@
+# aduc_ltx_latent_patch.py
+#
+# Este módulo fornece um monkey patch para a classe LTXVideoPipeline da biblioteca ltx_video.
+# A principal funcionalidade deste patch é otimizar o processo de condicionamento, permitindo
+# que a pipeline aceite tensores de latentes pré-calculados diretamente através de um
+# `ConditioningItem` modificado. Isso evita a re-codificação desnecessária de mídias (imagens/vídeos)
+# pela VAE, resultando em um ganho de performance significativo quando os latentes já estão disponíveis.
+
+import torch
+from torch import Tensor
+from typing import Optional, List, Tuple
+from pathlib import Path
+import os
+import sys
+
+DEPS_DIR = Path("/data")
+LTX_VIDEO_REPO_DIR = DEPS_DIR / "LTX-Video"
+def add_deps_to_path(repo_path: Path):
+    """Adiciona o diretório do repositório ao sys.path para importações locais."""
+    resolved_path = str(repo_path.resolve())
+    if resolved_path not in sys.path:
+        sys.path.insert(0, resolved_path)
+        if LTXV_DEBUG:
+            print(f"[DEBUG] Adicionado ao sys.path: {resolved_path}")
+
+# --- Execução da configuração inicial ---
+if not LTX_VIDEO_REPO_DIR.exists():
+    _run_setup_script()
+add_deps_to_path(LTX_VIDEO_REPO_DIR)
+
+
+# Tenta importar as dependências necessárias do módulo original que será modificado.
+# Isso requer que o ambiente Python tenha o pacote `ltx_video` acessível em seu sys.path.
+try:
+    from ltx_video.pipelines.pipeline_ltx_video import (
+        LTXVideoPipeline,
+        ConditioningItem as OriginalConditioningItem
+    )
+    from ltx_video.models.autoencoders.causal_video_autoencoder import CausalVideoAutoencoder
+    from ltx_video.models.autoencoders.vae_encode import vae_encode, latent_to_pixel_coords
+    from diffusers.utils.torch_utils import randn_tensor
+except ImportError as e:
+    print(f"FATAL ERROR: Could not import dependencies from 'ltx_video'. "
+          f"Please ensure the environment is correctly set up. Error: {e}")
+    # Interrompe a execução se as dependências essenciais não puderem ser encontradas.
+    raise
+
+print("[INFO] Patch module 'aduc_ltx_latent_patch' loaded successfully.")
+
+# ==============================================================================
+# 1. NOVA DEFINIÇÃO DA DATACLASS `ConditioningItem`
+# ==============================================================================
+
+from dataclasses import dataclass
+
+@dataclass
+class PatchedConditioningItem:
+    """
+    Versão modificada do `ConditioningItem` que aceita tensores de pixel (`media_item`)
+    ou tensores de latentes pré-codificados (`latents`).
+
+    Attributes:
+        media_frame_number (int): Quadro inicial do item de condicionamento no vídeo.
+        conditioning_strength (float): Força do condicionamento (0.0 a 1.0).
+        media_item (Optional[Tensor]): Tensor de mídia (pixels). Usado se `latents` for None.
+        media_x (Optional[int]): Coordenada X (esquerda) para posicionamento espacial.
+        media_y (Optional[int]): Coordenada Y (topo) para posicionamento espacial.
+        latents (Optional[Tensor]): Tensor de latentes pré-codificado. Terá precedência sobre `media_item`.
+    """
+    media_frame_number: int
+    conditioning_strength: float
+    media_item: Optional[Tensor] = None
+    media_x: Optional[int] = None
+    media_y: Optional[int] = None
+    latents: Optional[Tensor] = None
+
+    def __post_init__(self):
+        """Valida o estado do objeto após a inicialização."""
+        if self.media_item is None and self.latents is None:
+            raise ValueError("A `PatchedConditioningItem` must have either 'media_item' or 'latents' defined.")
+        if self.media_item is not None and self.latents is not None:
+            print("[WARNING] `PatchedConditioningItem` received both 'media_item' and 'latents'. "
+                  "The 'latents' tensor will take precedence.")
+
+# ==============================================================================
+# 2. NOVA IMPLEMENTAÇÃO DA FUNÇÃO `prepare_conditioning`
+# ==============================================================================
+
+def prepare_conditioning_with_latents(
+    self: LTXVideoPipeline,
+    conditioning_items: Optional[List[PatchedConditioningItem]],
+    init_latents: Tensor,
+    num_frames: int,
+    height: int,
+    width: int,
+    vae_per_channel_normalize: bool = False,
+    generator: Optional[torch.Generator] = None,
+) -> Tuple[Tensor, Tensor, Optional[Tensor], int]:
+    """
+    Versão modificada de `prepare_conditioning` que prioriza o uso de latentes pré-calculados
+    dos `conditioning_items`, evitando a re-codificação desnecessária pela VAE.
+    """
+    assert isinstance(self, LTXVideoPipeline), "This function must be called as a method of LTXVideoPipeline."
+    assert isinstance(self.vae, CausalVideoAutoencoder), "VAE must be of type CausalVideoAutoencoder."
+
+    # Se não há itens de condicionamento, apenas patchifica os latentes e retorna.
+    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
+
+    # Inicializa tensores para acumular resultados
+    init_conditioning_mask = torch.zeros(
+        init_latents[:, 0, :, :, :].shape, 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:
+        item_latents: Tensor
+
+        # --- LÓGICA CENTRAL DO PATCH ---
+        if item.latents is not None:
+            # 1. Se latentes pré-calculados existem, use-os diretamente.
+            item_latents = item.latents.to(dtype=init_latents.dtype, device=init_latents.device)
+            if item_latents.ndim != 5:
+                raise ValueError(f"Latents must have 5 dimensions (b, c, f, h, w), but got {item_latents.ndim}")
+        elif item.media_item is not None:
+            # 2. Caso contrário, volte para o fluxo original de codificação da VAE.
+            resized_item = self._resize_conditioning_item(item, height, width)
+            media_item = resized_item.media_item
+            assert media_item.ndim == 5, f"media_item must have 5 dims, but got {media_item.ndim}"
+
+            item_latents = vae_encode(
+                media_item.to(dtype=self.vae.dtype, device=self.vae.device),
+                self.vae,
+                vae_per_channel_normalize=vae_per_channel_normalize,
+            ).to(dtype=init_latents.dtype)
+        else:
+            # Este caso é prevenido pelo __post_init__ do dataclass, mas é bom ter uma checagem.
+            raise ValueError("ConditioningItem is invalid: it has neither 'latents' nor 'media_item'.")
+        # --- FIM DA LÓGICA DO PATCH ---
+
+        media_frame_number = item.media_frame_number
+        strength = item.conditioning_strength
+        
+        # O resto da lógica da função original é aplicado sobre `item_latents`.
+        if media_frame_number == 0:
+            item_latents, l_x, l_y = self._get_latent_spatial_position(
+                item_latents, item, height, width, strip_latent_border=True
+            )
+            _, _, f_l, h_l, w_l = item_latents.shape
+            init_latents[:, :, :f_l, l_y : l_y + h_l, l_x : l_x + w_l] = torch.lerp(
+                init_latents[:, :, :f_l, l_y : l_y + h_l, l_x : l_x + w_l], item_latents, strength
+            )
+            init_conditioning_mask[:, :f_l, l_y : l_y + h_l, l_x : l_x + w_l] = strength
+        else:
+            if item_latents.shape[2] > 1:
+                (init_latents, init_conditioning_mask, item_latents) = self._handle_non_first_conditioning_sequence(
+                    init_latents, init_conditioning_mask, item_latents, media_frame_number, strength
+                )
+
+            if item_latents is not None:
+                noise = randn_tensor(
+                    item_latents.shape, generator=generator,
+                    device=item_latents.device, dtype=item_latents.dtype
+                )
+                item_latents = torch.lerp(noise, item_latents, strength)
+                item_latents, latent_coords = self.patchifier.patchify(latents=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 += item_latents.shape[1]
+                conditioning_mask = torch.full(
+                    item_latents.shape[:2], strength,
+                    dtype=torch.float32, device=init_latents.device
+                )
+                extra_conditioning_latents.append(item_latents)
+                extra_conditioning_pixel_coords.append(pixel_coords)
+                extra_conditioning_mask.append(conditioning_mask)
+
+    # Patchifica os latentes principais e a máscara de condicionamento
+    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)
+
+    # Concatena os latentes extras (se houver)
+    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)
+
+        if self.transformer.use_tpu_flash_attention:
+            init_latents = init_latents[:, :-extra_conditioning_num_latents]
+            init_pixel_coords = init_pixel_coords[:, :, :-extra_conditioning_num_latents]
+            init_conditioning_mask = init_conditioning_mask[:, :-extra_conditioning_num_latents]
+
+    return init_latents, init_pixel_coords, init_conditioning_mask, extra_conditioning_num_latents
+
+
+# ==============================================================================
+# 3. CLASSE DO MONKEY PATCHER
+# ==============================================================================
+
+class LTXLatentConditioningPatch:
+    """
+    Classe estática para aplicar e reverter o monkey patch na pipeline LTX-Video.
+
+    Esta classe substitui o método `prepare_conditioning` da `LTXVideoPipeline`
+    pela versão otimizada que suporta latentes pré-calculados, e implicitamente
+    requer o uso da `PatchedConditioningItem`.
+    """
+    _original_prepare_conditioning = None
+    _is_patched = False
+
+    @staticmethod
+    def apply():
+        """
+        Aplica o monkey patch à classe `LTXVideoPipeline`.
+
+        Guarda o método original e o substitui pela nova implementação.
+        É idempotente; aplicar múltiplas vezes não causa efeito adicional.
+        """
+        if LTXLatentConditioningPatch._is_patched:
+            print("[WARNING] LTXLatentConditioningPatch has already been applied. Ignoring.")
+            return
+
+        print("[INFO] Applying monkey patch for latent-based conditioning...")
+
+        # Guarda a implementação original para permitir a reversão.
+        LTXLatentConditioningPatch._original_prepare_conditioning = LTXVideoPipeline.prepare_conditioning
+
+        # Substitui o método na classe LTXVideoPipeline.
+        # Todas as instâncias futuras e existentes da classe usarão este novo método.
+        LTXVideoPipeline.prepare_conditioning = prepare_conditioning_with_latents
+
+        LTXLatentConditioningPatch._is_patched = True
+        print("[SUCCESS] Monkey patch applied successfully.")
+        print("  - `LTXVideoPipeline.prepare_conditioning` has been updated.")
+        print("  - NOTE: Remember to use `aduc_ltx_latent_patch.PatchedConditioningItem` when creating conditioning items.")
+
+    @staticmethod
+    def revert():
+        """
+        Reverte o monkey patch, restaurando a implementação original.
+        """
+        if not LTXLatentConditioningPatch._is_patched:
+            print("[WARNING] Patch is not currently applied. No action taken.")
+            return
+
+        if LTXLatentConditioningPatch._original_prepare_conditioning:
+            print("[INFO] Reverting LTXLatentConditioningPatch...")
+            LTXVideoPipeline.prepare_conditioning = LTXLatentConditioningPatch._original_prepare_conditioning
+            LTXLatentConditioningPatch._is_patched = False
+            print("[SUCCESS] Patch reverted successfully. Original functionality restored.")
+        else:
+            print("[ERROR] Cannot revert: original implementation was not saved.")

api/gpu_manager.py

@@ -0,0 +1,56 @@
+# api/gpu_manager.py
+
+import os
+import torch
+
+class GPUManager:
+    """
+    Gerencia e aloca GPUs disponíveis para diferentes serviços (LTX, SeedVR).
+    """
+    def __init__(self):
+        self.total_gpus = torch.cuda.device_count()
+        self.ltx_gpus = []
+        self.seedvr_gpus = []
+        self._allocate_gpus()
+
+    def _allocate_gpus(self):
+        """
+        Divide as GPUs disponíveis entre os serviços LTX e SeedVR.
+        """
+        print("="*50)
+        print("🤖 Gerenciador de GPUs inicializado.")
+        print(f"   > Total de GPUs detectadas: {self.total_gpus}")
+
+        if self.total_gpus == 0:
+            print("   > Nenhuma GPU detectada. Operando em modo CPU.")
+        elif self.total_gpus == 1:
+            print("   > 1 GPU detectada. Modo de compartilhamento de memória será usado.")
+            # Ambos usarão a GPU 0, mas precisarão gerenciar a memória
+            self.ltx_gpus = [0]
+            self.seedvr_gpus = [0]
+        else:
+            # Divide as GPUs entre os dois serviços
+            mid_point = self.total_gpus // 2
+            self.ltx_gpus = list(range(0, mid_point))
+            self.seedvr_gpus = list(range(mid_point, self.total_gpus))
+            print(f"   > Alocação: LTX usará GPUs {self.ltx_gpus}, SeedVR usará GPUs {self.seedvr_gpus}.")
+        
+        print("="*50)
+
+    def get_ltx_device(self):
+        """Retorna o dispositivo principal para o LTX."""
+        if not self.ltx_gpus:
+            return torch.device("cpu")
+        # Por padrão, o modelo principal do LTX roda na primeira GPU do seu grupo
+        return torch.device(f"cuda:{self.ltx_gpus[0]}")
+
+    def get_seedvr_devices(self) -> list:
+        """Retorna a lista de IDs de GPU para o SeedVR."""
+        return self.seedvr_gpus
+
+    def requires_memory_swap(self) -> bool:
+        """Verifica se é necessário mover modelos entre CPU e GPU."""
+        return self.total_gpus < 2
+
+# Instância global para ser importada por outros módulos
+gpu_manager = GPUManager()

api/ltx_server_refactored.py

@@ -0,0 +1,814 @@
+# ltx_server_clean_refactor.py — VideoService (Modular Version with Simple Overlap Chunking)
+
+# ==============================================================================
+# 0. CONFIGURAÇÃO DE AMBIENTE E IMPORTAÇÕES
+# ==============================================================================
+import os
+import sys
+import gc
+import yaml
+import time
+import json
+import random
+import shutil
+import warnings
+import tempfile
+import traceback
+import subprocess
+from pathlib import Path
+from typing import List, Dict, Optional, Tuple, Union
+import cv2
+
+# --- Configurações de Logging e Avisos ---
+warnings.filterwarnings("ignore", category=UserWarning)
+warnings.filterwarnings("ignore", category=FutureWarning)
+from huggingface_hub import logging as hf_logging
+hf_logging.set_verbosity_error()
+
+# --- Importações de Bibliotecas de ML/Processamento ---
+import torch
+import torch.nn.functional as F
+import numpy as np
+from PIL import Image
+from einops import rearrange
+from huggingface_hub import hf_hub_download
+from safetensors import safe_open
+
+from managers.vae_manager import vae_manager_singleton
+from tools.video_encode_tool import video_encode_tool_singleton
+
+from api.aduc_ltx_latent_patch import LTXLatentConditioningPatch, PatchedConditioningItem
+
+# --- Constantes Globais ---
+LTXV_DEBUG = True  # Mude para False para desativar logs de debug
+LTXV_FRAME_LOG_EVERY = 8
+DEPS_DIR = Path("/data")
+LTX_VIDEO_REPO_DIR = DEPS_DIR / "LTX-Video"
+RESULTS_DIR = Path("/app/output")
+DEFAULT_FPS = 24.0
+
+# ==============================================================================
+# 1. SETUP E FUNÇÕES AUXILIARES DE AMBIENTE
+# ==============================================================================
+
+def _run_setup_script():
+    """Executa o script setup.py se o repositório LTX-Video não existir."""
+    setup_script_path = "setup.py"
+    if not os.path.exists(setup_script_path):
+        print("[DEBUG] 'setup.py' não encontrado. Pulando clonagem de dependências.")
+        return
+
+    print(f"[DEBUG] Repositório não encontrado em {LTX_VIDEO_REPO_DIR}. Executando setup.py...")
+    try:
+        subprocess.run([sys.executable, setup_script_path], check=True, capture_output=True, text=True)
+        print("[DEBUG] Script 'setup.py' concluído com sucesso.")
+    except subprocess.CalledProcessError as e:
+        print(f"[ERROR] Falha ao executar 'setup.py' (código {e.returncode}).\nOutput:\n{e.stdout}\n{e.stderr}")
+        sys.exit(1)
+
+def add_deps_to_path(repo_path: Path):
+    """Adiciona o diretório do repositório ao sys.path para importações locais."""
+    resolved_path = str(repo_path.resolve())
+    if resolved_path not in sys.path:
+        sys.path.insert(0, resolved_path)
+        if LTXV_DEBUG:
+            print(f"[DEBUG] Adicionado ao sys.path: {resolved_path}")
+
+# --- Execução da configuração inicial ---
+if not LTX_VIDEO_REPO_DIR.exists():
+    _run_setup_script()
+add_deps_to_path(LTX_VIDEO_REPO_DIR)
+
+# --- Importações Dependentes do Path Adicionado ---
+from ltx_video.models.autoencoders.vae_encode import un_normalize_latents, normalize_latents
+from ltx_video.pipelines.pipeline_ltx_video import adain_filter_latent
+from ltx_video.models.autoencoders.latent_upsampler import LatentUpsampler
+from ltx_video.pipelines.pipeline_ltx_video import ConditioningItem, LTXVideoPipeline
+from transformers import T5EncoderModel, T5Tokenizer, AutoModelForCausalLM, AutoProcessor, AutoTokenizer
+from ltx_video.models.autoencoders.causal_video_autoencoder import CausalVideoAutoencoder
+from ltx_video.models.transformers.symmetric_patchifier import SymmetricPatchifier
+from ltx_video.models.transformers.transformer3d import Transformer3DModel
+from ltx_video.schedulers.rf import RectifiedFlowScheduler
+from ltx_video.utils.skip_layer_strategy import SkipLayerStrategy
+import ltx_video.pipelines.crf_compressor as crf_compressor
+
+
+def create_latent_upsampler(latent_upsampler_model_path: str, device: str):
+    latent_upsampler = LatentUpsampler.from_pretrained(latent_upsampler_model_path)
+    latent_upsampler.to(device)
+    latent_upsampler.eval()
+    return latent_upsampler
+
+def create_ltx_video_pipeline(
+    ckpt_path: str,
+    precision: str,
+    text_encoder_model_name_or_path: str,
+    sampler: Optional[str] = None,
+    device: Optional[str] = None,
+    enhance_prompt: bool = False,
+    prompt_enhancer_image_caption_model_name_or_path: Optional[str] = None,
+    prompt_enhancer_llm_model_name_or_path: Optional[str] = None,
+) -> LTXVideoPipeline:
+    ckpt_path = Path(ckpt_path)
+    assert os.path.exists(
+        ckpt_path
+    ), f"Ckpt path provided (--ckpt_path) {ckpt_path} does not exist"
+
+    with safe_open(ckpt_path, framework="pt") as f:
+        metadata = f.metadata()
+        config_str = metadata.get("config")
+        configs = json.loads(config_str)
+        allowed_inference_steps = configs.get("allowed_inference_steps", None)
+
+    vae = CausalVideoAutoencoder.from_pretrained(ckpt_path)
+    transformer = Transformer3DModel.from_pretrained(ckpt_path)
+
+    # Use constructor if sampler is specified, otherwise use from_pretrained
+    if sampler == "from_checkpoint" or not sampler:
+        scheduler = RectifiedFlowScheduler.from_pretrained(ckpt_path)
+    else:
+        scheduler = RectifiedFlowScheduler(
+            sampler=("Uniform" if sampler.lower() == "uniform" else "LinearQuadratic")
+        )
+
+    text_encoder = T5EncoderModel.from_pretrained(
+        text_encoder_model_name_or_path, subfolder="text_encoder"
+    )
+    patchifier = SymmetricPatchifier(patch_size=1)
+    tokenizer = T5Tokenizer.from_pretrained(
+        text_encoder_model_name_or_path, subfolder="tokenizer"
+    )
+
+    transformer = transformer.to(device)
+    vae = vae.to(device)
+    text_encoder = text_encoder.to(device)
+
+    if enhance_prompt:
+        prompt_enhancer_image_caption_model = AutoModelForCausalLM.from_pretrained(
+            prompt_enhancer_image_caption_model_name_or_path, trust_remote_code=True
+        )
+        prompt_enhancer_image_caption_processor = AutoProcessor.from_pretrained(
+            prompt_enhancer_image_caption_model_name_or_path, trust_remote_code=True
+        )
+        prompt_enhancer_llm_model = AutoModelForCausalLM.from_pretrained(
+            prompt_enhancer_llm_model_name_or_path,
+            torch_dtype="bfloat16",
+        )
+        prompt_enhancer_llm_tokenizer = AutoTokenizer.from_pretrained(
+            prompt_enhancer_llm_model_name_or_path,
+        )
+    else:
+        prompt_enhancer_image_caption_model = None
+        prompt_enhancer_image_caption_processor = None
+        prompt_enhancer_llm_model = None
+        prompt_enhancer_llm_tokenizer = None
+
+    vae = vae.to(torch.bfloat16)
+    if precision == "bfloat16" and transformer.dtype != torch.bfloat16:
+        transformer = transformer.to(torch.bfloat16)
+    text_encoder = text_encoder.to(torch.bfloat16)
+
+    # Use submodels for the pipeline
+    submodel_dict = {
+        "transformer": transformer,
+        "patchifier": patchifier,
+        "text_encoder": text_encoder,
+        "tokenizer": tokenizer,
+        "scheduler": scheduler,
+        "vae": vae,
+        "prompt_enhancer_image_caption_model": prompt_enhancer_image_caption_model,
+        "prompt_enhancer_image_caption_processor": prompt_enhancer_image_caption_processor,
+        "prompt_enhancer_llm_model": prompt_enhancer_llm_model,
+        "prompt_enhancer_llm_tokenizer": prompt_enhancer_llm_tokenizer,
+        "allowed_inference_steps": allowed_inference_steps,
+    }
+
+    pipeline = LTXVideoPipeline(**submodel_dict)
+    
+    LTXLatentConditioningPatch.apply()
+    
+    pipeline = pipeline.to(device)
+    return pipeline
+
+# ==============================================================================
+# 2. FUNÇÕES AUXILIARES DE PROCESSAMENTO
+# ==============================================================================
+
+def calculate_padding(orig_h: int, orig_w: int, target_h: int, target_w: int) -> Tuple[int, int, int, int]:
+    """Calcula o preenchimento para centralizar uma imagem em uma nova dimensão."""
+    pad_h = target_h - orig_h
+    pad_w = target_w - orig_w
+    pad_top = pad_h // 2
+    pad_bottom = pad_h - pad_top
+    pad_left = pad_w // 2
+    pad_right = pad_w - pad_left
+    return (pad_left, pad_right, pad_top, pad_bottom)
+
+def log_tensor_info(tensor: torch.Tensor, name: str = "Tensor"):
+    """Exibe informações detalhadas sobre um tensor para depuração."""
+    if not isinstance(tensor, torch.Tensor):
+        print(f"\n[INFO] '{name}' não é um tensor.")
+        return
+    print(f"\n--- Tensor Info: {name} ---")
+    print(f"  - Shape:  {tuple(tensor.shape)}")
+    print(f"  - Dtype:  {tensor.dtype}")
+    print(f"  - Device: {tensor.device}")
+    if tensor.numel() > 0:
+        try:
+            print(f"  - Stats:  Min={tensor.min().item():.4f}, Max={tensor.max().item():.4f}, Mean={tensor.mean().item():.4f}")
+        except RuntimeError:
+            print("  - Stats: Não foi possível calcular (ex: tensores bool).")
+    print("-" * 30)
+
+# ==============================================================================
+# 3. CLASSE PRINCIPAL DO SERVIÇO DE VÍDEO
+# ==============================================================================
+
+class VideoService:
+    """
+    Serviço encapsulado para gerar vídeos usando a pipeline LTX-Video.
+    Gerencia o carregamento de modelos, pré-processamento, geração em múltiplos
+    passos (baixa resolução, upscale com denoise) e pós-processamento.
+    """
+    def __init__(self):
+        """Inicializa o serviço, carregando configurações e modelos."""
+        t0 = time.perf_counter()
+        print("[INFO] Inicializando VideoService...")
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.config = self._load_config("ltxv-13b-0.9.8-distilled-fp8.yaml")
+
+        self.pipeline, self.latent_upsampler = self._load_models_from_hub()
+        self._move_models_to_device()
+
+        self.runtime_autocast_dtype = self._get_precision_dtype()
+        vae_manager_singleton.attach_pipeline(
+            self.pipeline,
+            device=self.device,
+            autocast_dtype=self.runtime_autocast_dtype
+        )
+        self._tmp_dirs = set()
+        RESULTS_DIR.mkdir(exist_ok=True)
+        print(f"[INFO] VideoService pronto. Tempo de inicialização: {time.perf_counter()-t0:.2f}s")
+
+    # --------------------------------------------------------------------------
+    # --- Métodos Públicos (API do Serviço) ---
+    # --------------------------------------------------------------------------
+
+    def _load_image_to_tensor_with_resize_and_crop(
+        self,
+        image_input: Union[str, Image.Image],
+        target_height: int = 512,
+        target_width: int = 768,
+        just_crop: bool = False,
+    ) -> torch.Tensor:
+        """Load and process an image into a tensor.
+    
+        Args:
+            image_input: Either a file path (str) or a PIL Image object
+            target_height: Desired height of output tensor
+            target_width: Desired width of output tensor
+            just_crop: If True, only crop the image to the target size without resizing
+        """
+        if isinstance(image_input, str):
+            image = Image.open(image_input).convert("RGB")
+        elif isinstance(image_input, Image.Image):
+            image = image_input
+        else:
+            raise ValueError("image_input must be either a file path or a PIL Image object")
+    
+        input_width, input_height = image.size
+        aspect_ratio_target = target_width / target_height
+        aspect_ratio_frame = input_width / input_height
+        if aspect_ratio_frame > aspect_ratio_target:
+            new_width = int(input_height * aspect_ratio_target)
+            new_height = input_height
+            x_start = (input_width - new_width) // 2
+            y_start = 0
+        else:
+            new_width = input_width
+            new_height = int(input_width / aspect_ratio_target)
+            x_start = 0
+            y_start = (input_height - new_height) // 2
+    
+        image = image.crop((x_start, y_start, x_start + new_width, y_start + new_height))
+        if not just_crop:
+            image = image.resize((target_width, target_height))
+    
+        image = np.array(image)
+        image = cv2.GaussianBlur(image, (3, 3), 0)
+        frame_tensor = torch.from_numpy(image).float()
+        frame_tensor = crf_compressor.compress(frame_tensor / 255.0) * 255.0
+        frame_tensor = frame_tensor.permute(2, 0, 1)
+        frame_tensor = (frame_tensor / 127.5) - 1.0
+        # Create 5D tensor: (batch_size=1, channels=3, num_frames=1, height, width)
+        return frame_tensor.unsqueeze(0).unsqueeze(2)
+
+
+    
+    def generate_low_resolution1(self, prompt: str, negative_prompt: str, height: int, width: int, duration_secs: float, guidance_scale: float, seed: Optional[int] = None, conditioning_items: Optional[List[PatchedConditioningItem]] = None) -> Tuple[str, str, int]:
+        """
+        Gera um vídeo de baixa resolução e retorna os caminhos para o vídeo e os latentes.
+        """
+        used_seed = random.randint(0, 2**32 - 1) if seed is None else int(seed)
+        #self._seed_everething(used_seed)
+
+        actual_num_frames = max(9, int(round((round(duration_secs * DEFAULT_FPS) - 1) / 8.0) * 8 + 1))
+        
+        downscaled_height, downscaled_width = self._calculate_downscaled_dims(height, width)
+
+        first_pass_kwargs = {
+            "prompt": prompt, "negative_prompt": negative_prompt, "height": downscaled_height,
+            "width": downscaled_width, "num_frames": actual_num_frames, "frame_rate": int(DEFAULT_FPS),
+            "generator": torch.Generator(device=self.device).manual_seed(used_seed),
+            "output_type": "latent", "conditioning_items": conditioning_items,
+            "guidance_scale": float(guidance_scale), **(self.config.get("first_pass", {}))
+        }
+
+        temp_dir = tempfile.mkdtemp(prefix="ltxv_low_")
+        self._register_tmp_dir(temp_dir)
+        
+        try:
+            with torch.autocast(device_type=self.device.split(':')[0], 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_video_from_tensor(pixel_tensor, "low_res_video", used_seed, temp_dir)
+                latents_path = self._save_latents_to_disk(latents, "latents_low_res", used_seed)
+
+                log_tensor_info(latents, "first_pass_lat" )
+                self._finalize()
+                
+                final_video_path, final_latents_path = self.generate_upscale_denoise(
+                    latents_path=latents_path,
+                    prompt=prompt,
+                    negative_prompt=negative_prompt,
+                    guidance_scale=guidance_scale,
+                    seed=used_seed
+                )
+                
+                print(f"[SUCCESS] PASSO 2 concluído. Vídeo final em: {final_video_path}")
+
+            return final_video_path, final_latents_path, used_seed
+        
+        except Exception as e:
+            print(f"[ERROR] Falha na geração de baixa resolução: {e}")
+            traceback.print_exc()
+            raise
+        finally:
+            self._finalize()
+
+    
+    def _prepare_condition_items(self, items_list: List[Tuple], height: int, width: int) -> List[PatchedConditioningItem]:
+        """Prepara os tensores de condicionamento a partir de imagens ou tensores."""
+        if not items_list:
+            return []
+            
+        height_padded = ((height - 1) // 8 + 1) * 8
+        width_padded = ((width - 1) // 8 + 1) * 8
+        padding_values = calculate_padding(height, width, height_padded, width_padded)
+        
+        conditioning_items = []
+        for media, frame_idx, weight in items_list:
+            if isinstance(media, str):
+                tensor = self._prepare_conditioning_tensor_from_path(media, height, width, padding_values)
+            else: # Assume que é um tensor
+                tensor = media.to(self.device, dtype=self.runtime_autocast_dtype)
+            
+            # Garante que o frame de condicionamento esteja dentro dos limites do vídeo
+            safe_frame_idx = int(frame_idx)
+            conditioning_items.append(PatchedConditioningItem(tensor, safe_frame_idx, float(weight)))
+            
+        return PatchedConditioningItem
+
+    
+    def generate_upscale_denoise(self, latents_path: str, prompt: str, negative_prompt: str, guidance_scale: float, seed: Optional[int] = None) -> Tuple[str, str]:
+        """
+        Aplica upscale, AdaIN e Denoise em latentes de baixa resolução usando um processo de chunking.
+        """
+        used_seed = random.randint(0, 2**32 - 1) if seed is None else int(seed)
+        #seed_everything(used_seed)
+
+        temp_dir = tempfile.mkdtemp(prefix="ltxv_up_")
+        self._register_tmp_dir(temp_dir)
+
+        try:
+            latents_low = torch.load(latents_path).to(self.device)
+            with torch.autocast(device_type=self.device.split(':')[0], dtype=self.runtime_autocast_dtype, enabled=(self.device == 'cuda')):
+                upsampled_latents = self._upsample_and_filter_latents(latents_low)
+                del latents_low; torch.cuda.empty_cache()
+
+                chunks = self._split_latents_with_overlap(upsampled_latents)
+                refined_chunks = []
+
+                for chunk in chunks:
+                    if chunk.shape[2] <= 1: continue  # Pula chunks inválidos
+
+                    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
+                    refined_chunks.append(refined_chunk)
+
+                    log_tensor_info(refined_chunk, "refined_chunk" )
+   
+            final_latents = self._merge_chunks_with_overlap(refined_chunks)
+            
+            if LTXV_DEBUG:
+                log_tensor_info(final_latents, "Latentes Upscaled/Refinados Finais")
+
+            latents_path = self._save_latents_to_disk(final_latents, "latents_refined", used_seed)
+            pixel_tensor = vae_manager_singleton.decode(final_latents, decode_timestep=float(self.config.get("decode_timestep", 0.05)))
+            video_path = self._save_video_from_tensor(pixel_tensor, "refined_video", used_seed, temp_dir)
+
+            return video_path, latents_path
+            
+        except Exception as e:
+            print(f"[ERROR] Falha no processo de upscale e denoise: {e}")
+            traceback.print_exc()
+            raise
+        finally:
+            self._finalize()
+
+    def generate_low_resolution(
+        self,
+        prompt: str,
+        negative_prompt: str,
+        height: int,
+        width: int,
+        duration_secs: float,
+        guidance_scale: float,
+        seed: Optional[int] = None,
+        conditioning_items: Optional[List[PatchedConditioningItem]] = None
+    ) -> Tuple[str, str, int]:
+        """
+        ETAPA 1: Gera um vídeo e latentes em resolução base a partir de um prompt e
+        condicionamentos opcionais.
+        """
+        print("[INFO] Iniciando ETAPA 1: Geração de Baixa Resolução...")
+        
+        # --- Configuração de Seed e Diretórios ---
+        used_seed = random.randint(0, 2**32 - 1) if seed is None else int(seed)
+        #seed_everything(used_seed)
+        print(f"  - Usando Seed: {used_seed}")
+    
+        temp_dir = tempfile.mkdtemp(prefix="ltxv_low_")
+        self._register_tmp_dir(temp_dir)
+        results_dir = "/app/output"
+        os.makedirs(results_dir, exist_ok=True)
+    
+        # --- Cálculo de Dimensões e Frames ---
+        actual_num_frames = int(round(duration_secs * DEFAULT_FPS))
+        downscaled_height = height
+        downscaled_width = width
+        #self._calculate_downscaled_dims(height, width)
+
+                    
+        print(f"  - Frames: {actual_num_frames}, Duração: {duration_secs}s")
+        print(f"  - Dimensões de Saída: {downscaled_height}x{downscaled_width}")
+          
+        # --- Execução da Pipeline ---
+        with torch.autocast(device_type=self.device.split(':')[0], dtype=self.runtime_autocast_dtype, enabled=(self.device == 'cuda')):
+            
+            first_pass_kwargs = {
+                "prompt": prompt,
+                "negative_prompt": negative_prompt,
+                "height": downscaled_height,
+                "width": downscaled_width,
+                "num_frames": (actual_num_frames//8)+1,
+                "frame_rate": int(DEFAULT_FPS),
+                "generator": torch.Generator(device=self.device).manual_seed(used_seed),
+                "output_type": "latent",
+                "conditioning_items": conditioning_items,
+                "guidance_scale": float(guidance_scale),
+                **(self.config.get("first_pass", {}))
+            }
+            
+            print("  - Enviando para a pipeline LTX...")
+            latents = self.pipeline(**first_pass_kwargs).images
+            print(f"  - Latentes gerados com shape: {latents.shape}")
+            
+            # Decodifica os latentes para pixels para criar o vídeo de preview
+            #pixel_tensor = vae_manager_singleton.decode(latents.clone(), decode_timestep=float(self.config.get("decode_timestep", 0.05)))
+            
+            # Salva os artefatos de saída (vídeo e tensor de latentes)
+            #video_path = self._save_video_from_tensor(pixel_tensor, "low_res_video", used_seed, temp_dir)
+            tensor_path = self._save_latents_to_disk(latents, "latents_low_res", used_seed)
+            
+            self._finalize()
+
+            final_video_path, final_latents_path = self.refine_texture_only(
+                latents_path=tensor_path,
+                prompt=prompt,
+                negative_prompt=negative_prompt,
+                guidance_scale=guidance_scale,
+                seed=used_seed,
+                conditioning_items=conditioning_items,
+            ) 
+        
+        # --- Limpeza ---
+        self._finalize()
+        
+        print("[SUCCESS] ETAPA 1 Concluída.")
+        return final_video_path, final_latents_path, used_seed
+
+    
+    def refine_texture_only(
+        self,
+        latents_path: str,
+        prompt: str,
+        negative_prompt: str,
+        guidance_scale: float,
+        seed: Optional[int] = None,
+        conditioning_items: Optional[List[PatchedConditioningItem]] = None
+    ) -> Tuple[str, str]:
+        """
+        ETAPA 2: Refina a textura dos latentes existentes SEM alterar sua resolução
+        e SEM dividi-los em pedaços. O tensor inteiro é processado de uma só vez para
+        garantir máxima consistência temporal.
+        """
+        print("[INFO] Iniciando ETAPA 2: Refinamento de Textura...")
+    
+        # --- Configuração de Seed e Diretórios ---
+        used_seed = random.randint(0, 2**32 - 1) if seed is None else int(seed)
+        #seed_everything(used_seed)
+        print(f"  - Usando Seed (consistente com Etapa 1): {used_seed}")
+    
+        temp_dir = tempfile.mkdtemp(prefix="ltxv_refine_single_")
+        self._register_tmp_dir(temp_dir)
+        
+        # --- Carregamento dos Latentes ---
+        latents_to_refine = torch.load(latents_path).to(self.device)
+        print(f"  - Shape dos latentes de entrada: {latents_to_refine.shape}")
+        
+        if conditioning_items:
+            print(f"  - Usando {len(conditioning_items)} item(ns) de condicionamento para o refinamento.")
+    
+        # --- Execução da Pipeline ---
+        with torch.autocast(device_type=self.device.split(':')[0], dtype=self.runtime_autocast_dtype, enabled=(self.device == 'cuda')):
+            
+            # As dimensões são as mesmas do tensor de entrada
+            refine_height = latents_to_refine.shape[3] * self.pipeline.vae_scale_factor
+            refine_width = latents_to_refine.shape[4] * self.pipeline.vae_scale_factor
+            
+            second_pass_kwargs = {
+                "prompt": prompt,
+                "negative_prompt": negative_prompt,
+                "height": refine_height,
+                "width": refine_width,
+                "frame_rate": int(DEFAULT_FPS),
+                "num_frames": latents_to_refine.shape[2],
+                "latents": latents_to_refine,  # O tensor completo é passado aqui
+                "guidance_scale": float(guidance_scale),
+                "output_type": "latent",
+                "generator": torch.Generator(device=self.device).manual_seed(used_seed),
+                "conditioning_items": conditioning_items,
+                **(self.config.get("second_pass", {}))
+            }
+            
+            print("  - Enviando tensor completo para a pipeline de refinamento...")
+            final_latents = self.pipeline(**second_pass_kwargs).images
+            print(f"  - Latentes refinados com shape: {final_latents.shape}")
+    
+            # Decodifica os latentes refinados para pixels
+            pixel_tensor = vae_manager_singleton.decode(final_latents, decode_timestep=float(self.config.get("decode_timestep", 0.05)))
+            
+            # Salva os artefatos de saída
+            video_path_out = self._save_video_from_tensor(pixel_tensor, "refined_video_single_pass", used_seed, temp_dir)
+            latents_path_out = self._save_latents_to_disk(final_latents, "latents_refined_single_pass", used_seed)
+            
+        # --- Limpeza ---
+        # Libera os tensores da memória da GPU antes de finalizar.
+        del latents_to_refine
+        if 'final_latents' in locals():
+            del final_latents
+        if 'pixel_tensor' in locals():
+            del pixel_tensor
+        self._finalize()
+        
+        print("[SUCCESS] ETAPA 2 Concluída.")
+        return video_path_out, latents_path_out
+
+        
+    def encode_latents_to_mp4(self, latents_path: str, fps: int = int(DEFAULT_FPS)) -> str:
+        """Decodifica um tensor de latentes salvo e o salva como um vídeo MP4."""
+        latents = torch.load(latents_path)
+        temp_dir = tempfile.mkdtemp(prefix="ltxv_enc_")
+        self._register_tmp_dir(temp_dir)
+        seed = random.randint(0, 99999) # Seed apenas para nome do arquivo
+        
+        try:
+            chunks = self._split_latents_with_overlap(latents)
+            pixel_chunks = []
+            
+            with torch.autocast(device_type=self.device.split(':')[0], dtype=self.runtime_autocast_dtype, enabled=(self.device == 'cuda')):
+                for chunk in chunks:
+                    if chunk.shape[2] == 0: continue
+                    pixel_chunk = vae_manager_singleton.decode(chunk.to(self.device), decode_timestep=float(self.config.get("decode_timestep", 0.05)))
+                    pixel_chunks.append(pixel_chunk)
+            
+            final_pixel_tensor = self._merge_chunks_with_overlap(pixel_chunks)
+            final_video_path = self._save_video_from_tensor(final_pixel_tensor, f"final_video_{seed}", seed, temp_dir, fps=fps)
+            return final_video_path
+            
+        except Exception as e:
+            print(f"[ERROR] Falha ao encodar latentes para MP4: {e}")
+            traceback.print_exc()
+            raise
+        finally:
+            self._finalize()
+            
+    # --------------------------------------------------------------------------
+    # --- Métodos Internos e Auxiliares ---
+    # --------------------------------------------------------------------------
+
+    def _finalize(self):
+        """Limpa a memória da GPU e os diretórios temporários."""
+        if LTXV_DEBUG:
+            print("[DEBUG] Finalize: iniciando limpeza...")
+        
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            torch.cuda.ipc_collect()
+
+        # Limpa todos os diretórios temporários registrados
+        for d in list(self._tmp_dirs):
+            shutil.rmtree(d, ignore_errors=True)
+            self._tmp_dirs.remove(d)
+            if LTXV_DEBUG:
+                print(f"[DEBUG] Diretório temporário removido: {d}")
+
+    def _load_config(self, config_filename: str) -> Dict:
+        """Carrega o arquivo de configuração YAML."""
+        config_path = LTX_VIDEO_REPO_DIR / "configs" / config_filename
+        print(f"[INFO] Carregando configuração de: {config_path}")
+        with open(config_path, "r") as file:
+            return yaml.safe_load(file)
+
+    def _load_models_from_hub(self):
+        """Baixa e cria as instâncias da pipeline e do upsampler."""
+        t0 = time.perf_counter()
+        LTX_REPO = "Lightricks/LTX-Video"
+        
+        print("[INFO] Baixando checkpoint principal...")
+        self.config["checkpoint_path"] = hf_hub_download(
+            repo_id=LTX_REPO, filename=self.config["checkpoint_path"],
+            token=os.getenv("HF_TOKEN")
+        )
+        print(f"[INFO] Checkpoint principal em: {self.config['checkpoint_path']}")
+
+        print("[INFO] Construindo pipeline...")
+        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",  # Carrega em CPU primeiro
+            enhance_prompt=False
+        )
+        print("[INFO] Pipeline construída.")
+
+        latent_upsampler = None
+        if self.config.get("spatial_upscaler_model_path"):
+            print("[INFO] Baixando upscaler espacial...")
+            self.config["spatial_upscaler_model_path"] = hf_hub_download(
+                repo_id=LTX_REPO, filename=self.config["spatial_upscaler_model_path"],
+                token=os.getenv("HF_TOKEN")
+            )
+            print(f"[INFO] Upscaler em: {self.config['spatial_upscaler_model_path']}")
+            
+            print("[INFO] Construindo latent_upsampler...")
+            latent_upsampler = create_latent_upsampler(self.config["spatial_upscaler_model_path"], device="cpu")
+            print("[INFO] Latent upsampler construído.")
+
+        print(f"[INFO] Carregamento de modelos concluído em {time.perf_counter()-t0:.2f}s")
+        return pipeline, latent_upsampler
+        
+    def _move_models_to_device(self):
+        """Move os modelos carregados para o dispositivo de computação (GPU/CPU)."""
+        print(f"[INFO] Movendo modelos para o dispositivo: {self.device}")
+        self.pipeline.to(self.device)
+        if self.latent_upsampler:
+            self.latent_upsampler.to(self.device)
+
+    def _get_precision_dtype(self) -> torch.dtype:
+        """Determina o dtype para autocast com base na configuração de precisão."""
+        prec = str(self.config.get("precision", "")).lower()
+        if prec in ["float8_e4m3fn", "bfloat16"]:
+            return torch.bfloat16
+        elif prec == "mixed_precision":
+            return torch.float16
+        return torch.float32
+
+    @torch.no_grad()
+    def _upsample_and_filter_latents(self, latents: torch.Tensor) -> torch.Tensor:
+        """Aplica o upsample espacial e o filtro AdaIN aos latentes."""
+        if not self.latent_upsampler:
+            raise ValueError("Latent Upsampler não está carregado para a operação de upscale.")
+        
+        latents_unnormalized = un_normalize_latents(latents, self.pipeline.vae, vae_per_channel_normalize=True)
+        upsampled_latents_unnormalized = self.latent_upsampler(latents_unnormalized)
+        upsampled_latents_normalized = normalize_latents(upsampled_latents_unnormalized, self.pipeline.vae, vae_per_channel_normalize=True)
+        
+        # Filtro AdaIN para manter consistência de cor/estilo com o vídeo de baixa resolução
+        return adain_filter_latent(latents=upsampled_latents_normalized, reference_latents=latents)
+
+    def _prepare_conditioning_tensor_from_path(self, filepath: str, height: int, width: int, padding: Tuple) -> torch.Tensor:
+        """Carrega uma imagem, redimensiona, aplica padding e move para o dispositivo."""
+        tensor = self._load_image_to_tensor_with_resize_and_crop(filepath, height, width)
+        tensor = F.pad(tensor, padding)
+        return tensor.to(self.device, dtype=self.runtime_autocast_dtype)
+
+    def _calculate_downscaled_dims(self, height: int, width: int) -> Tuple[int, int]:
+        """Calcula as dimensões para o primeiro passo (baixa resolução)."""
+        height_padded = ((height - 1) // 8 + 1) * 8
+        width_padded = ((width - 1) // 8 + 1) * 8
+        
+        downscale_factor = self.config.get("downscale_factor", 0.6666666)
+        vae_scale_factor = self.pipeline.vae_scale_factor
+        
+        target_w = int(width_padded * downscale_factor)
+        downscaled_width = target_w - (target_w % vae_scale_factor)
+        
+        target_h = int(height_padded * downscale_factor)
+        downscaled_height = target_h - (target_h % vae_scale_factor)
+        
+        return downscaled_height, downscaled_width
+
+    def _split_latents_with_overlap(self, latents: torch.Tensor, overlap: int = 1) -> List[torch.Tensor]:
+        """Divide um tensor de latentes em dois chunks com sobreposição."""
+        total_frames = latents.shape[2]
+        if total_frames <= overlap:
+            return [latents]
+            
+        mid_point = max(overlap, total_frames // 2)
+        chunk1 = latents[:, :, :mid_point, :, :]
+        # O segundo chunk começa 'overlap' frames antes para criar a sobreposição
+        chunk2 = latents[:, :, mid_point - overlap:, :, :]
+        
+        return [c for c in [chunk1, chunk2] if c.shape[2] > 0]
+
+    def _merge_chunks_with_overlap(self, chunks: List[torch.Tensor], overlap: int = 1) -> torch.Tensor:
+        """Junta uma lista de chunks, removendo a sobreposição."""
+        if not chunks:
+            return torch.empty(0)
+        if len(chunks) == 1:
+            return chunks[0]
+            
+        # Pega o primeiro chunk sem o frame de sobreposição final
+        merged_list = [chunks[0][:, :, :-overlap, :, :]]
+        # Adiciona os chunks restantes
+        merged_list.extend(chunks[1:])
+        
+        return torch.cat(merged_list, dim=2)
+        
+    def _save_latents_to_disk(self, latents_tensor: torch.Tensor, base_filename: str, seed: int) -> str:
+        """Salva um tensor de latentes em um arquivo .pt."""
+        latents_cpu = latents_tensor.detach().to("cpu")
+        tensor_path = RESULTS_DIR / f"{base_filename}_{seed}.pt"
+        torch.save(latents_cpu, tensor_path)
+        if LTXV_DEBUG:
+            print(f"[DEBUG] Latentes salvos em: {tensor_path}")
+        return str(tensor_path)
+
+    def _save_video_from_tensor(self, pixel_tensor: torch.Tensor, base_filename: str, seed: int, temp_dir: str, fps: int = int(DEFAULT_FPS)) -> str:
+        """Salva um tensor de pixels como um arquivo de vídeo MP4."""
+        temp_path = os.path.join(temp_dir, f"{base_filename}_{seed}.mp4")
+        video_encode_tool_singleton.save_video_from_tensor(pixel_tensor, temp_path, fps=fps)
+        
+        final_path = RESULTS_DIR / f"{base_filename}_{seed}.mp4"
+        shutil.move(temp_path, final_path)
+        print(f"[INFO] Vídeo final salvo em: {final_path}")
+        return str(final_path)
+        
+
+    def _seed_everething(self, seed: int):
+        random.seed(seed)
+        np.random.seed(seed)
+        torch.manual_seed(seed)
+        if torch.cuda.is_available():
+            torch.cuda.manual_seed(seed)
+        if torch.backends.mps.is_available():
+            torch.mps.manual_seed(seed)
+        
+    
+    def _register_tmp_dir(self, dir_path: str):
+        """Registra um diretório temporário para limpeza posterior."""
+        if dir_path and os.path.isdir(dir_path):
+            self._tmp_dirs.add(dir_path)
+            if LTXV_DEBUG:
+                print(f"[DEBUG] Diretório temporário registrado: {dir_path}")
+
+# ==============================================================================
+# 4. INSTANCIAÇÃO E PONTO DE ENTRADA (Exemplo)
+# ==============================================================================
+
+print("Criando instância do VideoService. O carregamento do modelo começará agora...")
+video_generation_service = VideoService()
+print("Instância do VideoService pronta para uso.")

api/seedvr_server.py

@@ -1,111 +1,268 @@
+# api/seedvr_server.py
+
 import os
-import shutil
-import subprocess
 import sys
 import time
-import mimetypes
+import subprocess
+import queue
+import multiprocessing as mp
 from pathlib import Path
-from typing import List, Optional, Tuple
+from typing import Optional, Callable
+
+# --- 1. Import dos Módulos Compartilhados ---
+# É crucial que estes imports venham antes dos imports pesados (torch, etc.)
+# para que o ambiente de multiprocessing seja configurado corretamente.
+
+try:
+    # Importa o gerenciador de GPUs que centraliza a lógica de alocação
+    from api.gpu_manager import gpu_manager
+    # Importa o serviço do LTX para podermos comandá-lo a liberar a VRAM
+    from api.ltx_server_refactored import video_generation_service
+except ImportError:
+    print("ERRO FATAL: Não foi possível importar `gpu_manager` ou `video_generation_service`.")
+    print("Certifique-se de que os arquivos `gpu_manager.py` e `ltx_server_refactored.py` existem em `api/`.")
+    sys.exit(1)
+
+
+# --- 2. Configuração de Ambiente e CUDA ---
+if mp.get_start_method(allow_none=True) != 'spawn':
+    mp.set_start_method('spawn', force=True)
+
+os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "backend:cudaMallocAsync")
+
+# Adiciona o caminho do repositório SeedVR
+SEEDVR_REPO_PATH = Path(os.getenv("SEEDVR_ROOT", "/data/SeedVR"))
+if str(SEEDVR_REPO_PATH) not in sys.path:
+    sys.path.insert(0, str(SEEDVR_REPO_PATH))
+
+# Imports pesados
+import torch
+import cv2
+import numpy as np
+from datetime import datetime
+
 
-from huggingface_hub import hf_hub_download
+# --- 3. Funções Auxiliares de Processamento (Workers e I/O) ---
+# (Estas funções não precisam de alteração)
+
+def extract_frames_from_video(video_path, debug=False, skip_first_frames=0, load_cap=None):
+    if debug: print(f"🎬 [SeedVR] Extraindo frames de: {video_path}")
+    if not os.path.exists(video_path): raise FileNotFoundError(f"Arquivo de vídeo não encontrado: {video_path}")
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened(): raise ValueError(f"Não foi possível abrir o vídeo: {video_path}")
+    
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    frames = []
+    frames_loaded = 0
+    for i in range(frame_count):
+        ret, frame = cap.read()
+        if not ret: break
+        if i < skip_first_frames: continue
+        if load_cap and frames_loaded >= load_cap: break
+        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        frames.append(frame.astype(np.float32) / 255.0)
+        frames_loaded += 1
+    cap.release()
+    if not frames: raise ValueError(f"Nenhum frame extraído de: {video_path}")
+    if debug: print(f"✅ [SeedVR] {len(frames)} frames extraídos com sucesso.")
+    return torch.from_numpy(np.stack(frames)).to(torch.float16), fps
+
+def save_frames_to_video(frames_tensor, output_path, fps=30.0, debug=False):
+    if debug: print(f"💾 [SeedVR] Salvando {frames_tensor.shape[0]} frames em: {output_path}")
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    frames_np = (frames_tensor.cpu().numpy() * 255.0).astype(np.uint8)
+    T, H, W, _ = frames_np.shape
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_path, fourcc, fps, (W, H))
+    if not out.isOpened(): raise ValueError(f"Não foi possível criar o vídeo: {output_path}")
+    for frame in frames_np:
+        out.write(cv2.cvtColor(frame, cv2.COLOR_RGB2BGR))
+    out.release()
+    if debug: print(f"✅ [SeedVR] Vídeo salvo com sucesso: {output_path}")
+
+def _worker_process(proc_idx, device_id, frames_np, shared_args, return_queue, progress_queue=None):
+    """Processo filho (worker) que executa o upscaling em uma GPU dedicada."""
+    os.environ["CUDA_VISIBLE_DEVICES"] = str(device_id)
+    os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "backend:cudaMallocAsync")
+    
+    import torch
+    from src.core.model_manager import configure_runner
+    from src.core.generation import generation_loop
+    
+    try:
+        frames_tensor = torch.from_numpy(frames_np).to(torch.float16)
+        callback = (lambda b, t, _, m: progress_queue.put((proc_idx, b, t, m))) if progress_queue else None
+
+        runner = configure_runner(shared_args["model"], shared_args["model_dir"], shared_args["preserve_vram"], shared_args["debug"])
+        result_tensor = generation_loop(
+            runner=runner, images=frames_tensor, cfg_scale=1.0, seed=shared_args["seed"],
+            res_w=shared_args["resolution"], batch_size=shared_args["batch_size"],
+            preserve_vram=shared_args["preserve_vram"], temporal_overlap=0,
+            debug=shared_args["debug"], progress_callback=callback
+        )
+        return_queue.put((proc_idx, result_tensor.cpu().numpy()))
+    except Exception as e:
+        import traceback
+        error_msg = f"ERRO no worker {proc_idx} (GPU {device_id}): {e}\n{traceback.format_exc()}"
+        print(error_msg)
+        if progress_queue: progress_queue.put((proc_idx, -1, -1, error_msg))
+        return_queue.put((proc_idx, error_msg))
+
+# --- 4. CLASSE DO SERVIDOR PRINCIPAL ---
 
 class SeedVRServer:
     def __init__(self, **kwargs):
-        self.SEEDVR_ROOT = Path(os.getenv("SEEDVR_ROOT", "/data/SeedVR"))
-        # Apontamos para o nosso diretório de checkpoints customizado
-        self.CKPTS_ROOT = Path("/data/seedvr_models_fp16") 
-        self.OUTPUT_ROOT = Path(os.getenv("OUTPUT_ROOT", "/app/outputs"))
-        self.INPUT_ROOT = Path(os.getenv("INPUT_ROOT", "/app/inputs"))
+        """Inicializa o servidor, define os caminhos e prepara o ambiente."""
+        print("⚙️ SeedVRServer inicializando...")
+        self.SEEDVR_ROOT = SEEDVR_REPO_PATH
+        self.CKPTS_ROOT = Path("/data/seedvr_models_fp16")
+        self.OUTPUT_ROOT = Path(os.getenv("OUTPUT_ROOT", "/app/output"))
         self.HF_HOME_CACHE = Path(os.getenv("HF_HOME", "/data/.cache/huggingface"))
         self.REPO_URL = os.getenv("SEEDVR_GIT_URL", "https://github.com/numz/ComfyUI-SeedVR2_VideoUpscaler")
-        self.NUM_GPUS_TOTAL = int(os.getenv("NUM_GPUS", "4"))
         
-        print("🚀 SeedVRServer (FP16) inicializando e preparando o ambiente...")
-        for p in [self.SEEDVR_ROOT.parent, self.CKPTS_ROOT, self.OUTPUT_ROOT, self.INPUT_ROOT, self.HF_HOME_CACHE]:
+        # OBTÉM AS GPUS ALOCADAS PELO GERENCIADOR CENTRAL
+        self.device_list = gpu_manager.get_seedvr_devices()
+        self.num_gpus = len(self.device_list)
+        print(f"[SeedVR] Alocado para usar {self.num_gpus} GPU(s): {self.device_list}")
+
+        for p in [self.CKPTS_ROOT, self.OUTPUT_ROOT, self.HF_HOME_CACHE]:
             p.mkdir(parents=True, exist_ok=True)
-        
+
         self.setup_dependencies()
-        print("✅ SeedVRServer (FP16) pronto.")
+        print("📦 SeedVRServer pronto.")
 
     def setup_dependencies(self):
-        self._ensure_repo()
-        # O monkey patch agora é feito pelo start_seedvr.sh, não mais aqui.
-        self._ensure_model()
-
-    def _ensure_repo(self) -> None:
+        """Garante que o repositório e os modelos estão presentes."""
         if not (self.SEEDVR_ROOT / ".git").exists():
-            print(f"[SeedVRServer] Clonando repositório para {self.SEEDVR_ROOT}...")
+            print(f"[SeedVR] Clonando repositório para {self.SEEDVR_ROOT}...")
             subprocess.run(["git", "clone", "--depth", "1", self.REPO_URL, str(self.SEEDVR_ROOT)], check=True)
-        else:
-            print("[SeedVRServer] Repositório SeedVR já existe.")
-
-    def _ensure_model(self) -> None:
-        """Baixa os arquivos de modelo FP16 otimizados e suas dependências."""
-        print(f"[SeedVRServer] Verificando checkpoints (FP16) em {self.CKPTS_ROOT}...")
         
         model_files = {
-            "seedvr2_ema_3b_fp16.safetensors": "MonsterMMORPG/SeedVR2_SECourses", "ema_vae_fp16.safetensors": "MonsterMMORPG/SeedVR2_SECourses",
-            "pos_emb.pt": "ByteDance-Seed/SeedVR2-3B", "neg_emb.pt": "ByteDance-Seed/SeedVR2-3B"
+            "seedvr2_ema_7b_sharp_fp16.safetensors": "MonsterMMORPG/SeedVR2_SECourses",
+            "ema_vae_fp16.safetensors": "MonsterMMORPG/SeedVR2_SECourses"
         }
-        
         for filename, repo_id in model_files.items():
             if not (self.CKPTS_ROOT / filename).exists():
-                print(f"Baixando {filename} de {repo_id}...")
-                hf_hub_download(repo_id=repo_id, filename=filename, local_dir=str(self.CKPTS_ROOT), cache_dir=str(self.HF_HOME_CACHE), token=os.getenv("HF_TOKEN"))
-        print("[SeedVRServer] Checkpoints (FP16) estão no local correto.")
-    
-    def _prepare_job(self, input_file: str) -> Tuple[Path, Path]:
-        ts = f"{int(time.time())}_{os.urandom(4).hex()}"
-        job_input_dir = self.INPUT_ROOT / f"job_{ts}"
-        out_dir = self.OUTPUT_ROOT / f"run_{ts}"
-        job_input_dir.mkdir(parents=True, exist_ok=True)
-        out_dir.mkdir(parents=True, exist_ok=True)
-        shutil.copy2(input_file, job_input_dir / Path(input_file).name)
-        return job_input_dir, out_dir
-        
-    def run_inference(self, filepath: str, *, seed: int, resh: int, resw: int, spsize: int, fps: Optional[float] = None):
-        script = self.SEEDVR_ROOT / "inference_cli.py"
-        job_input_dir, outdir = self._prepare_job(filepath)
-        mediatype, _ = mimetypes.guess_type(filepath)
-        is_image = mediatype and mediatype.startswith("image")
-    
-        effective_nproc = 1 if is_image else self.NUM_GPUS_TOTAL
-        effective_spsize = 1 if is_image else spsize
-    
-        output_filename = f"result_{Path(filepath).stem}.mp4" if not is_image else f"{Path(filepath).stem}_upscaled"
-        output_filepath = outdir / output_filename
+                print(f"Baixando {filename}...")
+                from huggingface_hub import hf_hub_download
+                hf_hub_download(
+                    repo_id=repo_id, filename=filename, local_dir=str(self.CKPTS_ROOT),
+                    cache_dir=str(self.HF_HOME_CACHE), token=os.getenv("HF_TOKEN")
+                )
+        print("[SeedVR] Checkpoints verificados.")
 
+    def run_inference(
+        self,
+        file_path: str, *,
+        seed: int,
+        resolution: int,
+        batch_size: int,
+        model: str = "seedvr2_ema_7b_sharp_fp16.safetensors",
+        fps: Optional[float] = None,
+        debug: bool = True,
+        preserve_vram: bool = True,
+        progress: Optional[Callable] = None
+    ) -> str:
+        """
+        Executa o pipeline completo de upscaling de vídeo, gerenciando a memória da GPU.
+        """
+        if progress: progress(0.01, "⌛ Inicializando inferência SeedVR...")
+
+        # --- NÓ 1: GERENCIAMENTO DE MEMÓRIA (SWAP) ---
+        if gpu_manager.requires_memory_swap():
+            print("[SWAP] SeedVR precisa da GPU. Movendo LTX para a CPU...")
+            if progress: progress(0.02, "🔄 Liberando VRAM para o SeedVR...")
+            video_generation_service.move_to_cpu()
+            print("[SWAP] LTX movido para a CPU. VRAM liberada.")
 
-        
-        cmd = [
-            "torchrun", "--standalone", "--nnodes=1",
-            f"--nproc-per-node={effective_nproc}",
-            str(script),
-            "--video_path", str(filepath),
-            "--output", str(output_filepath),
-            "--model_dir", str(self.CKPTS_ROOT),
-            "--seed", str(seed),
-            "--cuda_device", "0",
-            "--resolution", str(resh),
-            "--batch_size", str(effective_spsize),
-            "--model", "seedvr2_ema_3b_fp16.safetensors",
-            "--preserve_vram",
-            "--debug",
-            "--output_format", "video" if not is_image else "png",
-        ]
-    
-    
-        print("SeedVRServer Comando:", " ".join(cmd))
         try:
-            subprocess.run(cmd, cwd=str(self.SEEDVR_ROOT), check=True, env=os.environ.copy(), stdout=sys.stdout, stderr=sys.stderr)
-            # Constrói a tupla de retorno de forma determinística
-            if is_image:
-                # CLI salva PNGs em diretório args.output (tratado como diretório quando outputformat=png)
-                image_dir = output_filepath if output_filepath.suffix == "" else output_filepath.with_suffix("")
-                return str(image_dir), None, outdir
-            else:
-                # CLI salva vídeo exatamente em output_filepath
-                return None, str(output_filepath), outdir
-        except Exception as e:
-            print(f"[UI ERROR] A inferência falhou: {e}")
-            return None, None, None
+            # --- NÓ 2: EXTRAÇÃO DE FRAMES ---
+            if progress: progress(0.05, "🎬 Extraindo frames do vídeo...")
+            frames_tensor, original_fps = extract_frames_from_video(file_path, debug)
+
+            # --- NÓ 3: DIVISÃO PARA MULTI-GPU ---
+            if self.num_gpus == 0:
+                raise RuntimeError("SeedVR requer pelo menos 1 GPU alocada, mas não encontrou nenhuma.")
+            
+            print(f"[SeedVR] Dividindo {frames_tensor.shape[0]} frames em {self.num_gpus} chunks para processamento paralelo.")
+            chunks = torch.chunk(frames_tensor, self.num_gpus, dim=0)
+            
+            manager = mp.Manager()
+            return_queue = manager.Queue()
+            progress_queue = manager.Queue() if progress else None
+            
+            shared_args = {
+                "model": model, "model_dir": str(self.CKPTS_ROOT), "preserve_vram": preserve_vram,
+                "debug": debug, "seed": seed, "resolution": resolution, "batch_size": batch_size
+            }
+
+            # --- NÓ 4: INÍCIO DOS WORKERS ---
+            if progress: progress(0.1, f"🚀 Iniciando geração em {self.num_gpus} GPU(s)...")
+            workers = []
+            for idx, device_id in enumerate(self.device_list):
+                p = mp.Process(target=_worker_process, args=(idx, device_id, chunks[idx].cpu().numpy(), shared_args, return_queue, progress_queue))
+                p.start()
+                workers.append(p)
+            
+            # --- NÓ 5: COLETA DE RESULTADOS E MONITORAMENTO ---
+            results_np = [None] * self.num_gpus
+            finished_workers = 0
+            worker_progress = [0.0] * self.num_gpus
+            while finished_workers < self.num_gpus:
+                if progress_queue:
+                    while not progress_queue.empty():
+                        try:
+                            p_idx, b_idx, b_total, msg = progress_queue.get_nowait()
+                            if b_idx == -1: raise RuntimeError(f"Erro no Worker {p_idx}: {msg}")
+                            if b_total > 0: worker_progress[p_idx] = b_idx / b_total
+                            total_progress = sum(worker_progress) / self.num_gpus
+                            progress(0.1 + total_progress * 0.85, desc=f"GPU {p_idx+1}/{self.num_gpus}: {msg}")
+                        except queue.Empty: pass
+                
+                try:
+                    proc_idx, result = return_queue.get(timeout=0.2)
+                    if isinstance(result, str): raise RuntimeError(f"Worker {proc_idx} falhou: {result}")
+                    results_np[proc_idx] = result
+                    worker_progress[proc_idx] = 1.0
+                    finished_workers += 1
+                except queue.Empty: pass
+
+            for p in workers: p.join()
+
+            # --- NÓ 6: FINALIZAÇÃO ---
+            if any(r is None for r in results_np):
+                raise RuntimeError("Um ou mais workers falharam ao retornar um resultado.")
+
+            result_tensor = torch.from_numpy(np.concatenate(results_np, axis=0)).to(torch.float16)
+            if progress: progress(0.95, "💾 Salvando o vídeo final...")
+            
+            out_dir = self.OUTPUT_ROOT / f"run_{int(time.time())}_{Path(file_path).stem}"
+            out_dir.mkdir(parents=True, exist_ok=True)
+            output_filepath = out_dir / f"result_{Path(file_path).stem}.mp4"
+
+            final_fps = fps if fps and fps > 0 else original_fps
+            save_frames_to_video(result_tensor, str(output_filepath), final_fps, debug)
+            
+            print(f"✅ Vídeo salvo com sucesso em: {output_filepath}")
+            return str(output_filepath)
+
+        finally:
+            # --- NÓ 7: RESTAURAÇÃO DE MEMÓRIA (SWAP BACK) ---
+            if gpu_manager.requires_memory_swap():
+                print("[SWAP] Inferência do SeedVR concluída. Movendo LTX de volta para a GPU...")
+                if progress: progress(0.99, "🔄 Restaurando o ambiente LTX...")
+                ltx_device = gpu_manager.get_ltx_device()
+                video_generation_service.move_to_device(ltx_device)
+                print(f"[SWAP] LTX de volta em {ltx_device}.")
+
+# --- PONTO DE ENTRADA ---
+if __name__ == "__main__":
+    print("🚀 Executando o servidor SeedVR em modo autônomo para inicialização...")
+    try:
+        server = SeedVRServer()
+        print("✅ Servidor inicializado com sucesso. Pronto para receber chamadas.")
+    except Exception as e:
+        print(f"❌ Falha ao inicializar o servidor SeedVR: {e}")
+        traceback.print_exc()
+        sys.exit(1)