Update api/ltx_server.py

api/ltx_server.py

@@ -108,6 +108,68 @@ def _query_gpu_processes_via_nvidiasmi(device_index: int) -> List[Dict]:
                 continue
     return results
 
+
+
+def calculate_new_dimensions(orig_w, orig_h, divisor=8):
+    """
+    Calcula novas dimensões mantendo a proporção, garantindo que ambos os
+    lados sejam divisíveis pelo divisor especificado (padrão 8).
+    """
+    if orig_w == 0 or orig_h == 0:
+        # Retorna um valor padrão seguro
+        return 512, 512
+
+    # Preserva a orientação (paisagem vs. retrato)
+    if orig_w >= orig_h:
+        # Paisagem ou quadrado
+        aspect_ratio = orig_w / orig_h
+        # Começa com uma altura base e calcula a largura
+        new_h = 512 # Altura base para paisagem
+        new_w = new_h * aspect_ratio
+    else:
+        # Retrato
+        aspect_ratio = orig_h / orig_w
+        # Começa com uma largura base e calcula a altura
+        new_w = 512 # Largura base para retrato
+        new_h = new_w * aspect_ratio
+        
+    # Arredonda AMBOS os valores para o múltiplo mais próximo do divisor
+    final_w = int(round(new_w / divisor)) * divisor
+    final_h = int(round(new_h / divisor)) * divisor
+
+    # Garante que as dimensões não sejam zero após o arredondamento
+    final_w = max(divisor, final_w)
+    final_h = max(divisor, final_h)
+
+    print(f"[Dimension Calc] Original: {orig_w}x{orig_h} -> Calculado: {new_w:.0f}x{new_h:.0f} -> Final (divisível por {divisor}): {final_w}x{final_h}")
+    return final_h, final_w # Retorna (altura, largura)
+
+
+def handle_media_upload_for_dims(filepath, current_h, current_w):
+    """
+    Esta função agora usará o novo cálculo robusto.
+    (O corpo desta função não precisa de alterações, pois ela já chama a função de cálculo)
+    """
+    if not filepath or not os.path.exists(str(filepath)):
+        return gr.update(value=current_h), gr.update(value=current_w)
+    try:
+        if str(filepath).lower().endswith(('.png', '.jpg', '.jpeg', '.webp')):
+            with Image.open(filepath) as img:
+                orig_w, orig_h = img.size
+        else: # Assumir que é um vídeo
+            with imageio.get_reader(filepath) as reader:
+                meta = reader.get_meta_data()
+                orig_w, orig_h = meta.get('size', (current_w, current_h))
+        
+        # Chama a nova função corrigida
+        new_h, new_w = calculate_new_dimensions(orig_w, orig_h)
+        
+        return gr.update(value=new_h), gr.update(value=new_w)
+    except Exception as e:
+        print(f"Erro ao processar mídia para dimensões: {e}")
+        return gr.update(value=current_h), gr.update(value=current_w)
+
+
 def _gpu_process_table(processes: List[Dict], current_pid: int) -> str:
     if not processes:
         return "  - Processos ativos: (nenhum)\n"
@@ -632,8 +694,8 @@ class VideoService:
         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
+        height_padded = ((height - 1) // 8 + 1) * 8
+        width_padded = ((width - 1) // 8 + 1) * 8
         padding_values = calculate_padding(height, width, height_padded, width_padded)
         generator = torch.Generator(device=self.device).manual_seed(used_seed)
         
@@ -652,14 +714,29 @@ class VideoService:
             print(f"[DEBUG] Conditioning items: {len(conditioning_items)}")
 
         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,
+            "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": "latent",
             "conditioning_items": conditioning_items if conditioning_items else None,
-            "media_items": None, # (Lógica para video-to-video omitida por clareza)
-            # ... (outros kwargs base como antes)
+            "media_items": None,
+            "decode_timestep": self.config["decode_timestep"],
+            "decode_noise_scale": self.config["decode_noise_scale"],
+            "stochastic_sampling": self.config["stochastic_sampling"],
+            "image_cond_noise_scale": 0.01,
+            "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,
         }
-        
+        print(f"[DEBUG] output_type={call_kwargs['output_type']} skip_layer_strategy={call_kwargs['skip_layer_strategy']}")
+
         latents = None
 
         try:
@@ -675,9 +752,20 @@ class VideoService:
                     
                     first_pass_config = self.config.get("first_pass", {}).copy()
                     downscale_factor = self.config.get("downscale_factor", 0.666)
+
+                    unrounded_width = width_padded * downscale_factor
+                    unrounded_height = height_padded * downscale_factor
+                    
+                    # Sanitiza as dimensões para serem divisíveis pelo fator do VAE (geralmente 8)
+                    # Usamos o mesmo divisor da UI para consistência.
+                    divisor = 8
+                    downscaled_width = int(round(unrounded_width / divisor)) * divisor
+                    downscaled_height = int(round(unrounded_height / divisor)) * divisor
+
+                    downscaled_width = max(divisor, downscaled_width)
+                    downscaled_height = max(divisor, downscaled_height)
                     
-                    downscaled_width = int(width_padded * downscale_factor)
-                    downscaled_height = int(height_padded * downscale_factor)
+                    print(f"[DEBUG] Dimensões do First Pass: Calculado ({unrounded_width:.0f}x{unrounded_height:.0f}) -> Sanitizado ({downscaled_width}x{downscaled_height})")
                     
                     first_pass_kwargs = call_kwargs.copy()
                     first_pass_kwargs.update({