Update app.py

app.py

@@ -108,19 +108,12 @@ def prepare_and_generate_video(
     progress=gr.Progress(track_tqdm=True)
 ):
     try:
-        conditions_data = [
-            (condition_image_1, condition_strength_1, condition_frame_index_1),
-            (condition_image_2, condition_strength_2, condition_frame_index_2)
-        ]
-        
-        if randomize_seed:
-            seed = random.randint(0, 2**32 - 1)
-
+        # Lógica para agrupar as condições *dentro* da função
+        # Cálculo de frames e resolução
         num_frames = int(duration * FPS) + 1
         temporal_compression = pipeline.vae_temporal_compression_ratio
         num_frames = ((num_frames - 1) // temporal_compression) * temporal_compression + 1
         
-        # Etapa 1: Preparar condições para baixa resolução
         downscale_factor = 2 / 3
         downscaled_height = int(height * downscale_factor)
         downscaled_width = int(width * downscale_factor)
@@ -128,45 +121,103 @@ def prepare_and_generate_video(
             downscaled_height, downscaled_width, pipeline.vae_temporal_compression_ratio
         )
         
-        conditions_low_res = []
-        for image, strength, frame_index in conditions_data:
-            if image is not None:
-                processed_image = ImageOps.fit(image, (downscaled_width, downscaled_height), Image.LANCZOS)
-                conditions_low_res.append(LTXVideoCondition(
-                    image=processed_image, strength=strength, frame_index=int(frame_index)
-                ))
         
-        pipeline_args_low_res = {"conditions": conditions_low_res} if conditions_low_res else {}
+        
+        conditions = []
+        if condition_image_1 is not None:
+            condition_image_1 = ImageOps.fit(condition_image_1, (downscaled_width, downscaled_height), Image.LANCZOS)
+            conditions.append(LTXVideoCondition(
+                image=condition_image_1,
+                strength=condition_strength_1,
+                frame_index=int(condition_frame_index_1)
+            ))
+        if condition_image_2 is not None:
+            condition_image_2 = ImageOps.fit(condition_image_2, (downscaled_width, downscaled_height), Image.LANCZOS)
+            conditions.append(LTXVideoCondition(
+                image=condition_image_2,
+                strength=condition_strength_2,
+                frame_index=int(condition_frame_index_2)
+            ))
+
+        pipeline_args = {}
+        if conditions:
+            pipeline_args["conditions"] = conditions
 
+        # Manipulação da seed
+        if randomize_seed:
+            seed = random.randint(0, 2**32 - 1)
+
+                
+        # ETAPA 1: Geração do vídeo em baixa resolução
         latents = pipeline(
-            prompt=prompt, negative_prompt=negative_prompt, width=downscaled_width, height=downscaled_height,
-            num_frames=num_frames, generator=torch.Generator().manual_seed(seed),
-            output_type="latent", **pipeline_args_low_res
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            width=downscaled_width,
+            height=downscaled_height,
+            num_frames=num_frames,
+            timesteps=[1000, 993, 987, 981, 975, 909, 725, 0.03],
+            decode_timestep=0.05,
+            decode_noise_scale=0.025,
+            image_cond_noise_scale=0.0,
+            guidance_scale=guidance_scale,
+            guidance_rescale=0.7,
+            generator=torch.Generator().manual_seed(seed),
+            output_type="latent",
+            **pipeline_args
         ).frames
 
-        # Etapa 2: Upscale
+        # ETAPA 2: Upscale dos latentes
         upscaled_height, upscaled_width = downscaled_height * 2, downscaled_width * 2
-        upscaled_latents = pipe_upsample(latents=latents, output_type="latent").frames
-
-        # Etapa 3: Preparar condições para alta resolução (para manter frames imutáveis)
-        conditions_high_res = []
-        for image, strength, frame_index in conditions_data:
-            if image is not None:
-                processed_image_high_res = ImageOps.fit(image, (upscaled_width, upscaled_height), Image.LANCZOS)
-                conditions_high_res.append(LTXVideoCondition(
-                    image=processed_image_high_res, strength=strength, frame_index=int(frame_index)
-                ))
+        upscaled_latents = pipe_upsample(
+            latents=latents,
+            output_type="latent"
+        ).frames
+
+
+
+        conditions = []
+        if condition_image_1 is not None:
+            condition_image_1 = ImageOps.fit(condition_image_1, (upscaled_width, upscaled_height), Image.LANCZOS)
+            conditions.append(LTXVideoCondition(
+                image=condition_image_1,
+                strength=condition_strength_1,
+                frame_index=int(condition_frame_index_1)
+            ))
+        if condition_image_2 is not None:
+            condition_image_2 = ImageOps.fit(condition_image_2, (upscaled_width, upscaled_height), Image.LANCZOS)
+            conditions.append(LTXVideoCondition(
+                image=condition_image_2,
+                strength=condition_strength_2,
+                frame_index=int(condition_frame_index_2)
+            ))
+
+        pipeline_args = {}
+        if conditions:
+            pipeline_args["conditions"] = conditions
+            
         
-        pipeline_args_high_res = {"conditions": conditions_high_res} if conditions_high_res else {}
 
+        # ETAPA 3: Denoise final em alta resolução
         final_video_frames_np = pipeline(
-            prompt=prompt, negative_prompt=negative_prompt, width=upscaled_width, height=upscaled_height,
-            num_frames=num_frames, denoise_strength=0.999, latents=upscaled_latents,
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            width=upscaled_width,
+            height=upscaled_height,
+            num_frames=num_frames,
+            denoise_strength=0.999,
+            timesteps=[1000, 909, 725, 421, 0],
+            latents=upscaled_latents,
+            decode_timestep=0.05,
+            decode_noise_scale=0.025,
+            image_cond_noise_scale=0.0,
+            guidance_scale=guidance_scale,
+            guidance_rescale=0.7,
             generator=torch.Generator(device="cuda").manual_seed(seed),
-            output_type="np", **pipeline_args_high_res
+            output_type="np",
+            **pipeline_args
         ).frames[0]
 
-        # Etapa 4: Exportação
+        # Exportação para arquivo MP4
         video_uint8_frames = [(frame * 255).astype(np.uint8) for frame in final_video_frames_np]
         output_filename = "output.mp4"
         with imageio.get_writer(output_filename, fps=FPS, quality=8, macro_block_size=1) as writer:
@@ -178,8 +229,6 @@ def prepare_and_generate_video(
         
     except Exception as e:
         print(f"Ocorreu um erro: {e}")
-        import traceback
-        traceback.print_exc()
         return None, seed
 
 # --- Interface Gráfica com Gradio ---