Update api/ltx_server_refactored.py

api/ltx_server_refactored.py

@@ -518,6 +518,252 @@ class VideoService:
             self.finalize(keep_paths=[])
             
 
+
+
+# Em api/ltx_server_refactored.py -> dentro da classe VideoService
+
+    # ==============================================================================
+    # --- FUNÇÕES DE GERAÇÃO ATUALIZADAS E MODULARES ---
+    # ==============================================================================
+
+    def _generate_single_chunk_low(
+        self, prompt, negative_prompt, 
+        height, width, num_frames, 
+        seed, ltx_configs_override=None):
+        """
+        [NÓ DE GERAÇÃO] Gera um ÚNICO chunk de latentes brutos.
+        """
+        print("\n" + "-"*20 + " INÍCIO: _generate_single_chunk_low " + "-"*20)
+        try:
+            height_padded = ((height - 1) // 8 + 1) * 8
+            width_padded = ((width - 1) // 8 + 1) * 8
+            generator = torch.Generator(device=self.device).manual_seed(seed)
+            
+            downscale_factor = self.config.get("downscale_factor", 0.6666666)
+            vae_scale_factor = self.pipeline.vae_scale_factor
+            
+            x_width = int(width_padded * downscale_factor)
+            downscaled_width = x_width - (x_width % vae_scale_factor)
+            x_height = int(height_padded * downscale_factor)
+            downscaled_height = x_height - (x_height % vae_scale_factor)
+            
+            all_conditions = ltx_configs_override.get("conditioning_items", [])
+
+            pipeline_kwargs = self.config.get("first_pass", {}).copy()
+
+            if ltx_configs_override:
+                print("[DEBUG] Sobrepondo configurações do LTX com valores da UI...")
+                preset = ltx_configs_override.get("guidance_preset")
+                if preset == "Customizado":
+                    try:
+                        pipeline_kwargs["guidance_scale"] = json.loads(ltx_configs_override["guidance_scale_list"])
+                        pipeline_kwargs["stg_scale"] = json.loads(ltx_configs_override["stg_scale_list"])
+                        pipeline_kwargs["guidance_timesteps"] = json.loads(ltx_configs_override["timesteps_list"])
+                    except Exception as e:
+                        print(f"  > ERRO ao parsear valores customizados: {e}. Usando Padrão.")
+                elif preset == "Agressivo":
+                    pipeline_kwargs["guidance_scale"] = [1, 2, 8, 12, 8, 2, 1]
+                    pipeline_kwargs["stg_scale"] = [0, 0, 5, 6, 5, 3, 2]
+                elif preset == "Suave":
+                    pipeline_kwargs["guidance_scale"] = [1, 1, 4, 5, 4, 1, 1]
+                    pipeline_kwargs["stg_scale"] = [0, 0, 2, 2, 2, 1, 0]
+                
+                pipeline_kwargs["num_inference_steps"] = ltx_configs_override.get("fp_num_inference_steps", pipeline_kwargs.get("num_inference_steps"))
+                pipeline_kwargs["skip_initial_inference_steps"] = ltx_configs_override.get("ship_initial_inference_steps", pipeline_kwargs.get("skip_initial_inference_steps"))
+                pipeline_kwargs["skip_final_inference_steps"] = ltx_configs_override.get("ship_final_inference_steps", pipeline_kwargs.get("skip_final_inference_steps"))
+
+            pipeline_kwargs.update({
+                "prompt": prompt, "negative_prompt": negative_prompt, "height": downscaled_height, "width": downscaled_width,
+                "num_frames": num_frames, "frame_rate": 24, "generator": generator, "output_type": "latent",
+                "conditioning_items": all_conditions if all_conditions else None,
+            })
+            
+            with torch.autocast(device_type="cuda", dtype=self.runtime_autocast_dtype, enabled=self.device.type == 'cuda'):
+                latents_bruto = self.pipeline(**pipeline_kwargs).images
+                log_tensor_info(latents_bruto, f"Latente Bruto Gerado para: '{prompt[:40]}...'")
+            
+            print("-" * 20 + " FIM: _generate_single_chunk_low " + "-"*20)
+            return latents_bruto
+        
+        except Exception as e:
+            print("-" * 20 + f" ERRO: _generate_single_chunk_low {e} " + "-"*20)
+            traceback.print_exc()
+            return None
+        finally:
+            torch.cuda.empty_cache()
+            torch.cuda.ipc_collect()
+            self.finalize(keep_paths=[])
+            
+
+    def generate_narrative_low(
+        self, prompt: str, negative_prompt, 
+        height, width, duration,
+        seed, initial_image_conditions=None, overlap_frames: int = 8,
+        ltx_configs_override: dict = None):
+        
+        print("\n" + "="*80)
+        print("======           INICIANDO GERAÇÃO NARRATIVA EM CHUNKS (LOW-RES)           ======")
+        print("="*80)
+        
+        used_seed = random.randint(0, 2**32 - 1) if seed is None else int(seed)
+        seed_everething(used_seed)
+        FPS = 24.0
+
+        prompt_list = [p.strip() for p in prompt.splitlines() if p.strip()]
+        num_chunks = len(prompt_list)
+        if num_chunks == 0: raise ValueError("O prompt está vazio ou não contém linhas válidas.")
+        
+        total_actual_frames = max(9, int(round((round(duration * FPS) - 1) / 8.0) * 8 + 1))
+        
+        if num_chunks > 1:
+            total_blocks = (total_actual_frames - 1) // 8
+            blocks_per_chunk = total_blocks // num_chunks
+            blocks_last_chunk = total_blocks - (blocks_per_chunk * (num_chunks - 1))
+            frames_per_chunk = blocks_per_chunk * 8 + 1
+            frames_per_chunk_last = blocks_last_chunk * 8 + 1
+        else:
+            frames_per_chunk = total_actual_frames
+            frames_per_chunk_last = total_actual_frames
+        
+        frames_per_chunk = max(9, frames_per_chunk)
+        frames_per_chunk_last = max(9, frames_per_chunk_last)
+        
+        poda_latents_num = overlap_frames // self.pipeline.video_scale_factor if self.pipeline.video_scale_factor > 0 else 0
+        
+        latentes_chunk_video = []
+        condition_item_latent_overlap = None
+        temp_dir = tempfile.mkdtemp(prefix="ltxv_narrative_"); self._register_tmp_dir(temp_dir)
+        results_dir = "/app/output"; os.makedirs(results_dir, exist_ok=True)
+        
+        for i, chunk_prompt in enumerate(prompt_list):
+            print(f"\n--- Gerando Chunk Narrativo {i+1}/{num_chunks}: '{chunk_prompt}' ---")
+
+            current_image_conditions = []
+            if initial_image_conditions:
+                cond_item_original = initial_image_conditions[0]
+                if i == 0:
+                    current_image_conditions.append(cond_item_original)
+                else:
+                    cond_item_fraco = ConditioningItem(
+                        media_item=cond_item_original.media_item, media_frame_number=0, conditioning_strength=0.1
+                    )
+                    current_image_conditions.append(cond_item_fraco)
+            
+            if ltx_configs_override is None: ltx_configs_override = {}
+            current_conditions = []
+            if current_image_conditions: current_conditions.extend(current_image_conditions)
+            if condition_item_latent_overlap: current_conditions.append(condition_item_latent_overlap)
+            ltx_configs_override["conditioning_items"] = current_conditions
+            
+            num_frames_para_gerar = frames_per_chunk_last if i == num_chunks - 1 else frames_per_chunk
+            if i > 0 and poda_latents_num > 0:
+                num_frames_para_gerar += overlap_frames
+            
+            latentes_bruto = self._generate_single_chunk_low(
+                prompt=chunk_prompt, negative_prompt=negative_prompt, height=height, width=width,
+                num_frames=num_frames_para_gerar, seed=used_seed + i,
+                ltx_configs_override=ltx_configs_override
+            )
+            
+            if latentes_bruto is None:
+                print(f"ERRO FATAL: A geração do chunk {i+1} falhou. Abortando.")
+                self.finalize(keep_paths=[])
+                return None, None, None
+
+            if i > 0 and poda_latents_num > 0:
+                 latentes_bruto = latentes_bruto[:, :, poda_latents_num:, :, :]
+
+            latentes_podado = latentes_bruto.clone().detach()
+            if i < num_chunks - 1 and poda_latents_num > 0:
+                latentes_podado = latentes_bruto[:, :, :-poda_latents_num, :, :].clone()
+                overlap_latents = latentes_bruto[:, :, -poda_latents_num:, :, :].clone()
+                condition_item_latent_overlap = ConditioningItem(
+                    media_item=overlap_latents, media_frame_number=0, conditioning_strength=1.0
+                )
+            latentes_chunk_video.append(latentes_podado)
+
+        final_latents_cpu = torch.cat(latentes_chunk_video, dim=2).cpu()
+        log_tensor_info(final_latents_cpu, "Tensor de Latentes Final Concatenado (CPU)")
+        
+        tensor_path = os.path.join(results_dir, f"latents_narrative_{used_seed}.pt")
+        torch.save(final_latents_cpu, tensor_path)
+        
+        try: 
+            with torch.autocast(device_type="cuda", dtype=self.runtime_autocast_dtype, enabled=self.device.type == 'cuda'):
+                final_latents_gpu = final_latents_cpu.to(self.device)
+                pixel_tensor = vae_manager_singleton.decode(final_latents_gpu, decode_timestep=float(self.config.get("decode_timestep", 0.05)))
+                video_path = self._save_and_log_video(pixel_tensor, "narrative_video", FPS, temp_dir, results_dir, used_seed)
+        
+            self.finalize(keep_paths=[video_path, tensor_path])
+            return video_path, tensor_path, used_seed
+        
+        except Exception as e:
+            print("-" * 20 + f" ERRO: generate_narrative_low {e} " + "-"*20)
+            traceback.print_exc()
+            return None
+        finally:
+            torch.cuda.empty_cache()
+            torch.cuda.ipc_collect()
+            self.finalize(keep_paths=[])
+            
+
+    def generate_single_low(
+        self, prompt: str, negative_prompt, 
+        height, width, duration,
+        seed, initial_image_conditions=None,
+        ltx_configs_override: dict = None):
+        
+        print("\n" + "="*80)
+        print("======             INICIANDO GERAÇÃO SIMPLES EM CHUNK ÚNICO (LOW-RES)             ======")
+        print("="*80)
+
+        used_seed = random.randint(0, 2**32 - 1) if seed is None else int(seed)
+        seed_everething(used_seed)
+        FPS = 24.0
+
+        total_actual_frames = max(9, int(round((round(duration * FPS) - 1) / 8.0) * 8 + 1))
+        
+        temp_dir = tempfile.mkdtemp(prefix="ltxv_single_"); self._register_tmp_dir(temp_dir)
+        results_dir = "/app/output"; os.makedirs(results_dir, exist_ok=True)
+
+        if ltx_configs_override is None: ltx_configs_override = {}
+        ltx_configs_override["conditioning_items"] = initial_image_conditions if initial_image_conditions else []
+
+        final_latents = self._generate_single_chunk_low(
+            prompt=prompt, negative_prompt=negative_prompt, height=height, width=width,
+            num_frames=total_actual_frames, seed=used_seed,
+            ltx_configs_override=ltx_configs_override
+        )
+
+        if final_latents is None:
+            print(f"ERRO FATAL: A geração do chunk único falhou. Abortando.")
+            self.finalize(keep_paths=[])
+            return None, None, None
+
+        final_latents_cpu = final_latents.cpu()
+        log_tensor_info(final_latents_cpu, "Tensor de Latentes Final (CPU)")
+
+        tensor_path = os.path.join(results_dir, f"latents_single_{used_seed}.pt")
+        torch.save(final_latents_cpu, tensor_path)
+
+        try:
+            with torch.autocast(device_type="cuda", dtype=self.runtime_autocast_dtype, enabled=self.device.type == 'cuda'):
+                final_latents_gpu = final_latents_cpu.to(self.device)
+                pixel_tensor = vae_manager_singleton.decode(final_latents_gpu, decode_timestep=float(self.config.get("decode_timestep", 0.05)))
+                video_path = self._save_and_log_video(pixel_tensor, "single_video", FPS, temp_dir, results_dir, used_seed)
+
+            self.finalize(keep_paths=[video_path, tensor_path])
+            return video_path, tensor_path, used_seed
+     
+        except Exception as e:
+            print("-" * 20 + f" ERRO: generate_single_low {e} " + "-"*20)
+            traceback.print_exc()
+            return None
+        finally:
+            torch.cuda.empty_cache()
+            torch.cuda.ipc_collect()
+            self.finalize(keep_paths=[])
+        
         
     # ==============================================================================
     # --- FUNÇÃO #4: ORQUESTRADOR  (Upscaler + texturas hd) ---