Image at any position

app.py

@@ -57,8 +57,8 @@ if torch.cuda.device_count() > 0:
     free_mem_gb = get_cuda_free_memory_gb(gpu)
     high_vram = free_mem_gb > 60
 
-    print(f'Free VRAM {free_mem_gb} GB')
-    print(f'High-VRAM Mode: {high_vram}')
+    #print(f'Free VRAM {free_mem_gb} GB')
+    #print(f'High-VRAM Mode: {high_vram}')
     
     text_encoder = LlamaModel.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='text_encoder', torch_dtype=torch.float16).cpu()
     text_encoder_2 = CLIPTextModel.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='text_encoder_2', torch_dtype=torch.float16).cpu()
@@ -82,7 +82,7 @@ if torch.cuda.device_count() > 0:
         vae.enable_tiling()
 
     transformer.high_quality_fp32_output_for_inference = True
-    print('transformer.high_quality_fp32_output_for_inference = True')
+    #print('transformer.high_quality_fp32_output_for_inference = True')
 
     transformer.to(dtype=torch.bfloat16)
     vae.to(dtype=torch.float16)
@@ -136,36 +136,36 @@ def video_encode(video_path, resolution, no_resize, vae, vae_batch_size=16, devi
     """
     # 20250506 pftq: Normalize video path for Windows compatibility
     video_path = str(pathlib.Path(video_path).resolve())
-    print(f"Processing video: {video_path}")
+    #print(f"Processing video: {video_path}")
 
     # 20250506 pftq: Check CUDA availability and fallback to CPU if needed
     if device == "cuda" and not torch.cuda.is_available():
-        print("CUDA is not available, falling back to CPU")
+        #print("CUDA is not available, falling back to CPU")
         device = "cpu"
 
     try:
         # 20250506 pftq: Load video and get FPS
-        print("Initializing VideoReader...")
+        #print("Initializing VideoReader...")
         vr = decord.VideoReader(video_path)
         fps = vr.get_avg_fps()  # Get input video FPS
         num_real_frames = len(vr)
-        print(f"Video loaded: {num_real_frames} frames, FPS: {fps}")
+        #print(f"Video loaded: {num_real_frames} frames, FPS: {fps}")
 
         # Truncate to nearest latent size (multiple of 4)
         latent_size_factor = 4
         num_frames = (num_real_frames // latent_size_factor) * latent_size_factor
-        if num_frames != num_real_frames:
-            print(f"Truncating video from {num_real_frames} to {num_frames} frames for latent size compatibility")
+        #if num_frames != num_real_frames:
+            #print(f"Truncating video from {num_real_frames} to {num_frames} frames for latent size compatibility")
         num_real_frames = num_frames
 
         # 20250506 pftq: Read frames
-        print("Reading video frames...")
+        #print("Reading video frames...")
         frames = vr.get_batch(range(num_real_frames)).asnumpy()  # Shape: (num_real_frames, height, width, channels)
-        print(f"Frames read: {frames.shape}")
+        #print(f"Frames read: {frames.shape}")
 
         # 20250506 pftq: Get native video resolution
         native_height, native_width = frames.shape[1], frames.shape[2]
-        print(f"Native video resolution: {native_width}x{native_height}")
+        #print(f"Native video resolution: {native_width}x{native_height}")
 
         # 20250506 pftq: Use native resolution if height/width not specified, otherwise use provided values
         target_height = native_height if height is None else height
@@ -174,9 +174,9 @@ def video_encode(video_path, resolution, no_resize, vae, vae_batch_size=16, devi
         # 20250506 pftq: Adjust to nearest bucket for model compatibility
         if not no_resize:
             target_height, target_width = find_nearest_bucket(target_height, target_width, resolution=resolution)
-            print(f"Adjusted resolution: {target_width}x{target_height}")
-        else:
-            print(f"Using native resolution without resizing: {target_width}x{target_height}")
+            #print(f"Adjusted resolution: {target_width}x{target_height}")
+        #else:
+            #print(f"Using native resolution without resizing: {target_width}x{target_height}")
 
         # 20250506 pftq: Preprocess frames to match original image processing
         processed_frames = []
@@ -185,34 +185,34 @@ def video_encode(video_path, resolution, no_resize, vae, vae_batch_size=16, devi
             frame_np = resize_and_center_crop(frame, target_width=target_width, target_height=target_height)
             processed_frames.append(frame_np)
         processed_frames = np.stack(processed_frames)  # Shape: (num_real_frames, height, width, channels)
-        print(f"Frames preprocessed: {processed_frames.shape}")
+        #print(f"Frames preprocessed: {processed_frames.shape}")
 
         # 20250506 pftq: Save first frame for CLIP vision encoding
         input_image_np = processed_frames[0]
 
         # 20250506 pftq: Convert to tensor and normalize to [-1, 1]
-        print("Converting frames to tensor...")
+        #print("Converting frames to tensor...")
         frames_pt = torch.from_numpy(processed_frames).float() / 127.5 - 1
         frames_pt = frames_pt.permute(0, 3, 1, 2)  # Shape: (num_real_frames, channels, height, width)
         frames_pt = frames_pt.unsqueeze(0)  # Shape: (1, num_real_frames, channels, height, width)
         frames_pt = frames_pt.permute(0, 2, 1, 3, 4)  # Shape: (1, channels, num_real_frames, height, width)
-        print(f"Tensor shape: {frames_pt.shape}")
+        #print(f"Tensor shape: {frames_pt.shape}")
 
         # 20250507 pftq: Save pixel frames for use in worker
         input_video_pixels = frames_pt.cpu()
 
         # 20250506 pftq: Move to device
-        print(f"Moving tensor to device: {device}")
+        #print(f"Moving tensor to device: {device}")
         frames_pt = frames_pt.to(device)
-        print("Tensor moved to device")
+        #print("Tensor moved to device")
 
         # 20250506 pftq: Move VAE to device
-        print(f"Moving VAE to device: {device}")
+        #print(f"Moving VAE to device: {device}")
         vae.to(device)
-        print("VAE moved to device")
+        #print("VAE moved to device")
 
         # 20250506 pftq: Encode frames in batches
-        print(f"Encoding input video frames in VAE batch size {vae_batch_size} (reduce if memory issues here or if forcing video resolution)")
+        #print(f"Encoding input video frames in VAE batch size {vae_batch_size} (reduce if memory issues here or if forcing video resolution)")
         latents = []
         vae.eval()
         with torch.no_grad():
@@ -238,19 +238,19 @@ def video_encode(video_path, resolution, no_resize, vae, vae_batch_size=16, devi
                     raise
 
         # 20250506 pftq: Concatenate latents
-        print("Concatenating latents...")
+        #print("Concatenating latents...")
         history_latents = torch.cat(latents, dim=2)  # Shape: (1, channels, frames, height//8, width//8)
-        print(f"History latents shape: {history_latents.shape}")
+        #print(f"History latents shape: {history_latents.shape}")
 
         # 20250506 pftq: Get first frame's latent
         start_latent = history_latents[:, :, :1]  # Shape: (1, channels, 1, height//8, width//8)
-        print(f"Start latent shape: {start_latent.shape}")
+        #print(f"Start latent shape: {start_latent.shape}")
 
         # 20250506 pftq: Move VAE back to CPU to free GPU memory
         if device == "cuda":
             vae.to(cpu)
             torch.cuda.empty_cache()
-            print("VAE moved back to CPU, CUDA cache cleared")
+            #print("VAE moved back to CPU, CUDA cache cleared")
 
         return start_latent, input_image_np, history_latents, fps, target_height, target_width, input_video_pixels
 
@@ -266,7 +266,7 @@ def set_mp4_comments_imageio_ffmpeg(input_file, comments):
 
         # Check if input file exists
         if not os.path.exists(input_file):
-            print(f"Error: Input file {input_file} does not exist")
+            #print(f"Error: Input file {input_file} does not exist")
             return False
 
         # Create a temporary file path
@@ -289,13 +289,13 @@ def set_mp4_comments_imageio_ffmpeg(input_file, comments):
         if result.returncode == 0:
             # Replace the original file with the modified one
             shutil.move(temp_file, input_file)
-            print(f"Successfully added comments to {input_file}")
+            #print(f"Successfully added comments to {input_file}")
             return True
         else:
             # Clean up temp file if FFmpeg fails
             if os.path.exists(temp_file):
                 os.remove(temp_file)
-            print(f"Error: FFmpeg failed with message:\n{result.stderr}")
+            #print(f"Error: FFmpeg failed with message:\n{result.stderr}")
             return False
 
     except Exception as e:
@@ -306,8 +306,7 @@ def set_mp4_comments_imageio_ffmpeg(input_file, comments):
         return False
 
 @torch.no_grad()
-def worker(input_image, image_position, prompts, n_prompt, seed, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, mp4_crf):
-    is_last_frame = (image_position == 100)
+def worker(input_image, image_position, prompts, n_prompt, seed, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, mp4_crf, fps_number):
     def encode_prompt(prompt, n_prompt):
         llama_vec, clip_l_pooler = encode_prompt_conds(prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)
 
@@ -325,9 +324,13 @@ def worker(input_image, image_position, prompts, n_prompt, seed, resolution, tot
         clip_l_pooler_n = clip_l_pooler_n.to(transformer.dtype)
         return [llama_vec, clip_l_pooler, llama_vec_n, clip_l_pooler_n, llama_attention_mask, llama_attention_mask_n]
 
-    total_latent_sections = (total_second_length * 30) / (latent_window_size * 4)
+    total_latent_sections = (total_second_length * fps_number) / (latent_window_size * 4)
     total_latent_sections = int(max(round(total_latent_sections), 1))
 
+    first_section_index = max(min(math.floor(image_position * (total_latent_sections - 1) / 100), (total_latent_sections - 1)), 0)
+    section_index = first_section_index
+    forward = (image_position == 0)
+
     job_id = generate_timestamp()
 
     stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Starting ...'))))
@@ -349,9 +352,15 @@ def worker(input_image, image_position, prompts, n_prompt, seed, resolution, tot
 
         prompt_parameters = []
 
-        for prompt_part in prompts:
+        for prompt_part in prompts[:total_latent_sections]:
             prompt_parameters.append(encode_prompt(prompt_part, n_prompt))
 
+        # Clean GPU
+        if not high_vram:
+            unload_complete_models(
+                text_encoder, text_encoder_2
+            )
+
         # Processing input image
 
         stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Image processing ...'))))
@@ -403,7 +412,7 @@ def worker(input_image, image_position, prompts, n_prompt, seed, resolution, tot
         start_latent = start_latent.to(history_latents)
         history_pixels = None
 
-        history_latents = torch.cat([start_latent, history_latents] if is_last_frame else [history_latents, start_latent], dim=2)
+        history_latents = torch.cat([history_latents, start_latent] if forward else [start_latent, history_latents], dim=2)
         total_generated_latent_frames = 1
 
         if enable_preview:
@@ -421,65 +430,69 @@ def worker(input_image, image_position, prompts, n_prompt, seed, resolution, tot
                 current_step = d['i'] + 1
                 percentage = int(100.0 * current_step / steps)
                 hint = f'Sampling {current_step}/{steps}'
-                desc = f'Total generated frames: {int(max(0, total_generated_latent_frames * 4 - 3))}, Video length: {max(0, (total_generated_latent_frames * 4 - 3) / 30) :.2f} seconds (FPS-30), Resolution: {height}px * {width}px. The video is being extended now ...'
+                desc = f'Total generated frames: {int(max(0, total_generated_latent_frames * 4 - 3))}, Video length: {max(0, (total_generated_latent_frames * 4 - 3) / fps_number) :.2f} seconds (FPS-30), Resolution: {height}px * {width}px. The video is being extended now ...'
                 stream.output_queue.push(('progress', (preview, desc, make_progress_bar_html(percentage, hint))))
                 return
         else:
             def callback(d):
                 return
 
-        indices = torch.arange(0, sum([1, 16, 2, 1, latent_window_size])).unsqueeze(0)
-        if is_last_frame:
-            latent_indices, clean_latent_1x_indices, clean_latent_2x_indices, clean_latent_4x_indices, clean_latent_indices_start = indices.split([latent_window_size, 1, 2, 16, 1], dim=1)
-            clean_latent_indices = torch.cat([clean_latent_1x_indices, clean_latent_indices_start], dim=1)
-        else:
+        indices = torch.arange(0, 1 + 16 + 2 + 1 + latent_window_size).unsqueeze(0)
+        if forward:
             clean_latent_indices_start, clean_latent_4x_indices, clean_latent_2x_indices, clean_latent_1x_indices, latent_indices = indices.split([1, 16, 2, 1, latent_window_size], dim=1)
             clean_latent_indices = torch.cat([clean_latent_indices_start, clean_latent_1x_indices], dim=1)
+        else:
+            latent_indices, clean_latent_1x_indices, clean_latent_2x_indices, clean_latent_4x_indices, clean_latent_indices_start = indices.split([latent_window_size, 1, 2, 16, 1], dim=1)
+            clean_latent_indices = torch.cat([clean_latent_1x_indices, clean_latent_indices_start], dim=1)
 
-        def post_process(generated_latents, total_generated_latent_frames, history_latents, high_vram, transformer, gpu, vae, history_pixels, latent_window_size, enable_preview, section_index, total_latent_sections, outputs_folder, mp4_crf, stream):
+        def post_process(forward, generated_latents, total_generated_latent_frames, history_latents, high_vram, transformer, gpu, vae, history_pixels, latent_window_size, enable_preview, section_index, total_latent_sections, outputs_folder, mp4_crf, stream):
             total_generated_latent_frames += int(generated_latents.shape[2])
-            history_latents = torch.cat([generated_latents.to(history_latents), history_latents], dim=2) if is_last_frame else torch.cat([history_latents, generated_latents.to(history_latents)], dim=2)
+            history_latents = torch.cat([history_latents, generated_latents.to(history_latents)] if forward else [generated_latents.to(history_latents), history_latents], dim=2)
 
             if not high_vram:
                 offload_model_from_device_for_memory_preservation(transformer, target_device=gpu, preserved_memory_gb=8)
                 load_model_as_complete(vae, target_device=gpu)
 
             if history_pixels is None:
-                real_history_latents = history_latents[:, :, :total_generated_latent_frames, :, :] if is_last_frame else history_latents[:, :, -total_generated_latent_frames:, :, :]
+                real_history_latents = history_latents[:, :, -total_generated_latent_frames:, :, :] if forward else history_latents[:, :, :total_generated_latent_frames, :, :]
                 history_pixels = vae_decode(real_history_latents, vae).cpu()
             else:
                 section_latent_frames = latent_window_size * 2
                 overlapped_frames = latent_window_size * 4 - 3
 
-                if is_last_frame:
-                    real_history_latents = history_latents[:, :, :min(section_latent_frames, total_generated_latent_frames), :, :]
-                    history_pixels = soft_append_bcthw(vae_decode(real_history_latents, vae).cpu(), history_pixels, overlapped_frames)
-                else:
+                if forward:
                     real_history_latents = history_latents[:, :, -min(section_latent_frames, total_generated_latent_frames):, :, :]
                     history_pixels = soft_append_bcthw(history_pixels, vae_decode(real_history_latents, vae).cpu(), overlapped_frames)
+                else:
+                    real_history_latents = history_latents[:, :, :min(section_latent_frames, total_generated_latent_frames), :, :]
+                    history_pixels = soft_append_bcthw(vae_decode(real_history_latents, vae).cpu(), history_pixels, overlapped_frames)
 
             if not high_vram:
                 unload_complete_models()
 
-            if enable_preview or section_index == (0 if is_last_frame else (total_latent_sections - 1)):
+            if enable_preview or section_index == (0 if first_section_index == (total_latent_sections - 1) else (total_latent_sections - 1)):
                 output_filename = os.path.join(outputs_folder, f'{job_id}_{total_generated_latent_frames}.mp4')
 
-                save_bcthw_as_mp4(history_pixels, output_filename, fps=30, crf=mp4_crf)
+                save_bcthw_as_mp4(history_pixels, output_filename, fps=fps_number, crf=mp4_crf)
 
                 print(f'Decoded. Current latent shape pixel shape {history_pixels.shape}')
 
                 stream.output_queue.push(('file', output_filename))
             return [total_generated_latent_frames, history_latents, history_pixels]
-
-        for section_index in range(total_latent_sections - 1, -1, -1) if is_last_frame else range(total_latent_sections):
+        
+        while section_index < total_latent_sections:
             if stream.input_queue.top() == 'end':
                 stream.output_queue.push(('end', None))
                 return
 
             print(f'section_index = {section_index}, total_latent_sections = {total_latent_sections}')
 
-            if len(prompt_parameters) > 0:
-                [llama_vec, clip_l_pooler, llama_vec_n, clip_l_pooler_n, llama_attention_mask, llama_attention_mask_n] = prompt_parameters.pop((len(prompt_parameters) - 1) if is_last_frame else 0)
+            prompt_index = min(section_index, len(prompt_parameters) - 1)
+
+            [llama_vec, clip_l_pooler, llama_vec_n, clip_l_pooler_n, llama_attention_mask, llama_attention_mask_n] = prompt_parameters[prompt_index]
+            
+            if prompt_index < len(prompt_parameters) - 1 or (prompt_index == total_latent_sections - 1):
+                prompt_parameters[prompt_index] = None
 
             if not high_vram:
                 unload_complete_models()
@@ -490,12 +503,12 @@ def worker(input_image, image_position, prompts, n_prompt, seed, resolution, tot
             else:
                 transformer.initialize_teacache(enable_teacache=False)
 
-            if is_last_frame:
-                clean_latents_1x, clean_latents_2x, clean_latents_4x = history_latents[:, :, :sum([1, 2, 16]), :, :].split([1, 2, 16], dim=2)
-                clean_latents = torch.cat([clean_latents_1x, start_latent], dim=2)
-            else:
-                clean_latents_4x, clean_latents_2x, clean_latents_1x = history_latents[:, :, -sum([16, 2, 1]):, :, :].split([16, 2, 1], dim=2)
+            if forward:
+                clean_latents_4x, clean_latents_2x, clean_latents_1x = history_latents[:, :, -(16 + 2 + 1):, :, :].split([16, 2, 1], dim=2)
                 clean_latents = torch.cat([start_latent, clean_latents_1x], dim=2)
+            else:
+                clean_latents_1x, clean_latents_2x, clean_latents_4x = history_latents[:, :, :(1 + 2 + 16), :, :].split([1, 2, 16], dim=2)
+                clean_latents = torch.cat([clean_latents_1x, start_latent], dim=2)
 
             generated_latents = sample_hunyuan(
                 transformer=transformer,
@@ -528,7 +541,25 @@ def worker(input_image, image_position, prompts, n_prompt, seed, resolution, tot
                 callback=callback,
             )
 
-            [total_generated_latent_frames, history_latents, history_pixels] = post_process(generated_latents, total_generated_latent_frames, history_latents, high_vram, transformer, gpu, vae, history_pixels, latent_window_size, enable_preview, section_index, total_latent_sections, outputs_folder, mp4_crf, stream)
+            [total_generated_latent_frames, history_latents, history_pixels] = post_process(forward, generated_latents, total_generated_latent_frames, history_latents, high_vram, transformer, gpu, vae, history_pixels, latent_window_size, enable_preview, section_index, total_latent_sections, outputs_folder, mp4_crf, stream)
+            
+            if not forward:
+                if section_index > 0:
+                    section_index -= 1
+                else:
+                    clean_latent_indices_start, clean_latent_4x_indices, clean_latent_2x_indices, clean_latent_1x_indices, latent_indices = indices.split([1, 16, 2, 1, latent_window_size], dim=1)
+                    clean_latent_indices = torch.cat([clean_latent_indices_start, clean_latent_1x_indices], dim=1)
+
+                    real_history_latents = history_latents[:, :, :total_generated_latent_frames, :, :]
+                    zero_latents = history_latents[:, :, total_generated_latent_frames:, :, :]
+                    history_latents = torch.cat([zero_latents, real_history_latents], dim=2)
+                    real_history_latents = zero_latents = None
+                    
+                    forward = True
+                    section_index = first_section_index
+            
+            if forward:
+                section_index += 1
     except:
         traceback.print_exc()
 
@@ -563,6 +594,17 @@ def worker_video(input_video, prompts, n_prompt, seed, batch, resolution, total_
     stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Starting ...'))))
 
     try:
+        # 20250506 pftq: Processing input video instead of image
+        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Video processing ...'))))
+
+        # 20250506 pftq: Encode video
+        start_latent, input_image_np, video_latents, fps, height, width = video_encode(input_video, resolution, no_resize, vae, vae_batch_size=vae_batch, device=gpu)[:6]
+        start_latent = start_latent.to(dtype=torch.float32).cpu()
+        video_latents = video_latents.cpu()
+
+        total_latent_sections = (total_second_length * fps) / (latent_window_size * 4)
+        total_latent_sections = int(max(round(total_latent_sections), 1))
+
         # Clean GPU
         if not high_vram:
             unload_complete_models(
@@ -578,16 +620,14 @@ def worker_video(input_video, prompts, n_prompt, seed, batch, resolution, total_
 
         prompt_parameters = []
 
-        for prompt_part in prompts:
+        for prompt_part in prompts[:total_latent_sections]:
             prompt_parameters.append(encode_prompt(prompt_part, n_prompt))
 
-        # 20250506 pftq: Processing input video instead of image
-        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Video processing ...'))))
-
-        # 20250506 pftq: Encode video
-        start_latent, input_image_np, video_latents, fps, height, width = video_encode(input_video, resolution, no_resize, vae, vae_batch_size=vae_batch, device=gpu)[:6]
-        start_latent = start_latent.to(dtype=torch.float32).cpu()
-        video_latents = video_latents.cpu()
+        # Clean GPU
+        if not high_vram:
+            unload_complete_models(
+                text_encoder, text_encoder_2
+            )
 
         # CLIP Vision
         stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'CLIP Vision encoding ...'))))
@@ -601,9 +641,6 @@ def worker_video(input_video, prompts, n_prompt, seed, batch, resolution, total_
         # Dtype
         image_encoder_last_hidden_state = image_encoder_last_hidden_state.to(transformer.dtype)
 
-        total_latent_sections = (total_second_length * fps) / (latent_window_size * 4)
-        total_latent_sections = int(max(round(total_latent_sections), 1))
-
         if enable_preview:
             def callback(d):
                 preview = d['denoised']
@@ -640,7 +677,7 @@ def worker_video(input_video, prompts, n_prompt, seed, batch, resolution, total_
             total_context_frames = num_4x_frames + num_2x_frames + effective_clean_frames
             total_context_frames = min(total_context_frames, available_frames)  # 20250507 pftq: Edge case for <=1 sec videos
 
-            indices = torch.arange(0, sum([1, num_4x_frames, num_2x_frames, effective_clean_frames, adjusted_latent_frames])).unsqueeze(0) # 20250507 pftq: latent_window_size to adjusted_latent_frames for edge case for <=1 sec videos
+            indices = torch.arange(0, 1 + num_4x_frames + num_2x_frames + effective_clean_frames + adjusted_latent_frames).unsqueeze(0) # 20250507 pftq: latent_window_size to adjusted_latent_frames for edge case for <=1 sec videos
             clean_latent_indices_start, clean_latent_4x_indices, clean_latent_2x_indices, clean_latent_1x_indices, latent_indices = indices.split(
                 [1, num_4x_frames, num_2x_frames, effective_clean_frames, adjusted_latent_frames], dim=1 # 20250507 pftq: latent_window_size to adjusted_latent_frames for edge case for <=1 sec videos
             )
@@ -809,34 +846,18 @@ def worker_video(input_video, prompts, n_prompt, seed, batch, resolution, total_
     stream.output_queue.push(('end', None))
     return
 
-def get_duration(input_image, image_position, prompts, generation_mode, n_prompt, seed, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, mp4_crf):
-    return total_second_length * 60 * (0.9 if use_teacache else 1.5) * (1 + ((steps - 25) / 100))
+def get_duration(input_image, image_position, prompts, generation_mode, n_prompt, seed, resolution, total_second_length, allocation_time, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, mp4_crf, fps_number):
+    return allocation_time
 
 # Remove this decorator if you run on local
 @spaces.GPU(duration=get_duration)
-def process_on_gpu(input_image,
-            image_position=0,
-            prompts=[""],
-            generation_mode="image",
-            n_prompt="",
-            seed=31337,
-            resolution=640,
-            total_second_length=5,
-            latent_window_size=9,
-            steps=25,
-            cfg=1.0,
-            gs=10.0,
-            rs=0.0,
-            gpu_memory_preservation=6,
-            enable_preview=True,
-            use_teacache=False,
-            mp4_crf=16
+def process_on_gpu(input_image, image_position, prompts, generation_mode, n_prompt, seed, resolution, total_second_length, allocation_time, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, mp4_crf, fps_number
            ):
     start = time.time()
     global stream
     stream = AsyncStream()
 
-    async_run(worker, input_image, image_position, prompts, n_prompt, seed, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, mp4_crf)
+    async_run(worker, input_image, image_position, prompts, n_prompt, seed, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, mp4_crf, fps_number)
 
     output_filename = None
 
@@ -845,11 +866,11 @@ def process_on_gpu(input_image,
 
         if flag == 'file':
             output_filename = data
-            yield gr.update(value=output_filename, label="Previewed Frames"), gr.update(), gr.update(), gr.update(), gr.update(interactive=False), gr.update(interactive=True), gr.update()
+            yield gr.update(value=output_filename, label="Previewed Frames"), gr.skip(), gr.skip(), gr.skip(), gr.update(interactive=False), gr.update(interactive=True), gr.skip()
 
         if flag == 'progress':
             preview, desc, html = data
-            yield gr.update(label="Previewed Frames"), gr.update(visible=True, value=preview), desc, html, gr.update(interactive=False), gr.update(interactive=True), gr.update()
+            yield gr.update(label="Previewed Frames"), gr.update(visible=True, value=preview), desc, html, gr.update(interactive=False), gr.update(interactive=True), gr.skip()
 
         if flag == 'end':
             end = time.time()
@@ -858,7 +879,7 @@ def process_on_gpu(input_image,
             secondes = secondes - (minutes * 60)
             hours = math.floor(minutes / 60)
             minutes = minutes - (hours * 60)
-            yield gr.update(value=output_filename, label="Finished Frames"), gr.update(visible=False), gr.update(), "The process has lasted " + \
+            yield gr.update(value=output_filename, label="Finished Frames"), gr.update(visible=False), gr.skip(), "The process has lasted " + \
             ((str(hours) + " h, ") if hours != 0 else "") + \
             ((str(minutes) + " min, ") if hours != 0 or minutes != 0 else "") + \
             str(secondes) + " sec. " + \
@@ -872,6 +893,8 @@ def process(input_image,
             n_prompt="",
             randomize_seed=True,
             seed=31337,
+            auto_allocation=True,
+            allocation_time=180,
             resolution=640,
             total_second_length=5,
             latent_window_size=9,
@@ -882,12 +905,15 @@ def process(input_image,
             gpu_memory_preservation=6,
             enable_preview=True,
             use_teacache=False,
-            mp4_crf=16
+            mp4_crf=16,
+            fps_number=30
            ):
+    if auto_allocation:
+        allocation_time = min(total_second_length * 60 * (0.9 if use_teacache else 3.0) * (1 + ((steps - 25) / 25)), 600)
 
     if torch.cuda.device_count() == 0:
         gr.Warning('Set this space to GPU config to make it work.')
-        yield gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(visible = False)
+        yield gr.skip(), gr.skip(), gr.skip(), gr.skip(), gr.skip(), gr.skip(), gr.update(visible = False)
         return
 
     if randomize_seed:
@@ -901,7 +927,7 @@ def process(input_image,
         input_image = np.ones((default_height, default_width, 3), dtype=np.uint8) * 255
         print("No input image provided. Using a blank white image.")
 
-    yield gr.update(label="Previewed Frames"), None, '', '', gr.update(interactive=False), gr.update(interactive=True), gr.update()
+    yield gr.update(label="Previewed Frames"), None, '', '', gr.update(interactive=False), gr.update(interactive=True), gr.skip()
 
     yield from process_on_gpu(input_image,
             image_position,
@@ -911,6 +937,7 @@ def process(input_image,
             seed,
             resolution,
             total_second_length,
+            allocation_time,
             latent_window_size,
             steps,
             cfg,
@@ -919,15 +946,16 @@ def process(input_image,
             gpu_memory_preservation,
             enable_preview,
             use_teacache,
-            mp4_crf
+            mp4_crf,
+            fps_number
            )
 
-def get_duration_video(input_video, prompts, n_prompt, seed, batch, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch):
-    return total_second_length * 60 * (1.5 if use_teacache else 2.5) * (1 + ((steps - 25) / 100))
+def get_duration_video(input_video, prompts, n_prompt, seed, batch, resolution, total_second_length, allocation_time, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch):
+    return allocation_time
 
 # Remove this decorator if you run on local
 @spaces.GPU(duration=get_duration_video)
-def process_video_on_gpu(input_video, prompts, n_prompt, seed, batch, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch):
+def process_video_on_gpu(input_video, prompts, n_prompt, seed, batch, resolution, total_second_length, allocation_time, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch):
     start = time.time()
     global stream
     stream = AsyncStream()
@@ -942,11 +970,11 @@ def process_video_on_gpu(input_video, prompts, n_prompt, seed, batch, resolution
 
         if flag == 'file':
             output_filename = data
-            yield gr.update(value=output_filename, label="Previewed Frames"), gr.update(), gr.update(), gr.update(), gr.update(interactive=False), gr.update(interactive=True), gr.update()
+            yield gr.update(value=output_filename, label="Previewed Frames"), gr.skip(), gr.skip(), gr.skip(), gr.update(interactive=False), gr.update(interactive=True), gr.skip()
 
         if flag == 'progress':
             preview, desc, html = data
-            yield gr.update(label="Previewed Frames"), gr.update(visible=True, value=preview), desc, html, gr.update(interactive=False), gr.update(interactive=True), gr.update() # 20250506 pftq: Keep refreshing the video in case it got hidden when the tab was in the background
+            yield gr.update(label="Previewed Frames"), gr.update(visible=True, value=preview), desc, html, gr.update(interactive=False), gr.update(interactive=True), gr.skip() # 20250506 pftq: Keep refreshing the video in case it got hidden when the tab was in the background
 
         if flag == 'end':
             end = time.time()
@@ -963,12 +991,14 @@ def process_video_on_gpu(input_video, prompts, n_prompt, seed, batch, resolution
             " You can upscale the result with RIFE. To make all your generated scenes consistent, you can then apply a face swap on the main character. If you do not see the generated video above, the process may have failed. See the logs for more information. If you see an error like ''NVML_SUCCESS == r INTERNAL ASSERT FAILED'', you probably haven't enough VRAM. Test an example or other options to compare. You can share your inputs to the original space or set your space in public for a peer review.", '', gr.update(interactive=True), gr.update(interactive=False), gr.update(visible = False)
             break
 
-def process_video(input_video, prompt, n_prompt, randomize_seed, seed, batch, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch):
+def process_video(input_video, prompt, n_prompt, randomize_seed, seed, auto_allocation, allocation_time, batch, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch):
     global high_vram
+    if auto_allocation:
+        allocation_time = min(total_second_length * 60 * (1.5 if use_teacache else 3.0) * (1 + ((steps - 25) / 25)), 600)
 
     if torch.cuda.device_count() == 0:
         gr.Warning('Set this space to GPU config to make it work.')
-        yield gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(visible = False)
+        yield gr.skip(), gr.skip(), gr.skip(), gr.skip(), gr.skip(), gr.skip(), gr.update(visible = False)
         return
 
     if randomize_seed:
@@ -979,7 +1009,7 @@ def process_video(input_video, prompt, n_prompt, randomize_seed, seed, batch, re
     # 20250506 pftq: Updated assertion for video input
     assert input_video is not None, 'No input video!'
 
-    yield gr.update(label="Previewed Frames"), None, '', '', gr.update(interactive=False), gr.update(interactive=True), gr.update()
+    yield gr.update(label="Previewed Frames"), None, '', '', gr.update(interactive=False), gr.update(interactive=True), gr.skip()
 
     # 20250507 pftq: Even the H100 needs offloading if the video dimensions are 720p or higher
     if high_vram and (no_resize or resolution>640):
@@ -994,7 +1024,7 @@ def process_video(input_video, prompt, n_prompt, randomize_seed, seed, batch, re
     if cfg > 1:
         gs = 1
 
-    yield from process_video_on_gpu(input_video, prompts, n_prompt, seed, batch, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch)
+    yield from process_video_on_gpu(input_video, prompts, n_prompt, seed, batch, resolution, total_second_length, allocation_time, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch)
 
 def end_process():
     stream.input_queue.push('end')
@@ -1065,9 +1095,9 @@ with block:
     with gr.Row():
         with gr.Column():
             generation_mode = gr.Radio([["Text-to-Video", "text"], ["Image-to-Video", "image"], ["Video Extension", "video"]], elem_id="generation-mode", label="Generation mode", value = "image")
-            text_to_video_hint = gr.HTML("I discourage to use the Text-to-Video feature. You should rather generate an image with Flux and use Image-to-Video. You will save time.")
+            text_to_video_hint = gr.HTML("Text-to-Video badly works. I discourage to use the Text-to-Video feature. You should rather generate an image with Flux and use Image-to-Video. You will save time.")
             input_image = gr.Image(sources='upload', type="numpy", label="Image", height=320)
-            image_position = gr.Slider(label="Image position", minimum=0, maximum=100, value=0, step=100, info='0=Video start; 100=Video end (lower quality)')
+            image_position = gr.Slider(label="Image position", minimum=0, maximum=100, value=0, step=1, info='0=Video start; 100=Video end (lower quality)')
             input_video = gr.Video(sources='upload', label="Input Video", height=320)
             timeless_prompt = gr.Textbox(label="Timeless prompt", info='Used on the whole duration of the generation', value='', placeholder="The creature starts to move, fast motion, fixed camera, focus motion, consistent arm, consistent position, mute colors, insanely detailed")
             prompt_number = gr.Slider(label="Timed prompt number", minimum=0, maximum=1000, value=0, step=1, info='Prompts will automatically appear')
@@ -1081,7 +1111,7 @@ with block:
 
             final_prompt = gr.Textbox(label="Final prompt", value='', info='Use ; to separate in time; beware to write to stop the previous action')
             prompt_hint = gr.HTML("Video extension barely follows the prompt; to force to follow the prompt, you have to set the Distilled CFG Scale to 3.0 and the Context Frames to 2 but the video quality will be poor.")
-            total_second_length = gr.Slider(label="Video Length to Generate (seconds)", minimum=1, maximum=120, value=2, step=0.1)
+            total_second_length = gr.Slider(label="Video length to generate (seconds if 30 fps)", minimum=1, maximum=120, value=2, step=0.1)
 
             with gr.Row():
                 start_button = gr.Button(value="🎥 Generate", variant="primary")
@@ -1094,6 +1124,8 @@ with block:
 
                 n_prompt = gr.Textbox(label="Negative Prompt", value="Missing arm, unrealistic position, impossible contortion, visible bone, muscle contraction, blurred, blurry", info='Requires using normal CFG (undistilled) instead of Distilled (set Distilled=1 and CFG > 1).')
 
+                fps_number = gr.Slider(label="Frame per seconds", info="The model is trained for 30 fps so other fps may generate weird results", minimum=10, maximum=60, value=30, step=1)
+
                 latent_window_size = gr.Slider(label="Latent Window Size", minimum=1, maximum=33, value=9, step=1, info='Generate more frames at a time (larger chunks). Less degradation and better blending but higher VRAM cost. Should not change.')
                 steps = gr.Slider(label="Steps", minimum=1, maximum=100, value=30, step=1, info='Increase for more quality, especially if using high non-distilled CFG. If your animation has very few motion, you may have brutal brightness change; this can be fixed increasing the steps.')
 
@@ -1134,6 +1166,9 @@ with block:
                 with gr.Row():
                     randomize_seed = gr.Checkbox(label='Randomize seed', value=True, info='If checked, the seed is always different')
                     seed = gr.Slider(label="Seed", minimum=0, maximum=np.iinfo(np.int32).max, step=1, randomize=True)
+                with gr.Row():
+                    auto_allocation = gr.Checkbox(label='Auto allocation', value=True, info='If checked, the GPU allocation time is estimated from the parameters')
+                    allocation_time = gr.Slider(label="GPU allocation time (in seconds)", info='lower=May abort run, higher=Quota penalty for next runs; only useful for ZeroGPU; for instance set to 88 when you have the message "You have exceeded your GPU quota (180s requested vs. 89s left)."', value=180, minimum=60, maximum=320, step=1)
 
         with gr.Column():
             warning = gr.HTML(value = "<center><big>Your computer must <u>not</u> enter into standby mode.</big><br/>On Chrome, you can force to keep a tab alive in <code>chrome://discards/</code></center>", visible = False)
@@ -1143,11 +1178,11 @@ with block:
             progress_bar = gr.HTML('', elem_classes='no-generating-animation')
 
     # 20250506 pftq: Updated inputs to include num_clean_frames
-    ips = [input_image, image_position, final_prompt, generation_mode, n_prompt, randomize_seed, seed, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, mp4_crf]
-    ips_video = [input_video, final_prompt, n_prompt, randomize_seed, seed, batch, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch]
+    ips = [input_image, image_position, final_prompt, generation_mode, n_prompt, randomize_seed, seed, auto_allocation, allocation_time, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, mp4_crf, fps_number]
+    ips_video = [input_video, final_prompt, n_prompt, randomize_seed, seed, auto_allocation, allocation_time, batch, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch]
 
     gr.Examples(
-        label = "Examples from text",
+        label = "✍️ Examples from text",
         examples = [
                 [
                     None, # input_image
@@ -1157,6 +1192,8 @@ with block:
                     "Missing arm, unrealistic position, impossible contortion, visible bone, muscle contraction, blurred, blurry", # n_prompt
                     True, # randomize_seed
                     42, # seed
+                    True, # auto_allocation
+                    180, # allocation_time
                     672, # resolution
                     1, # total_second_length
                     9, # latent_window_size
@@ -1167,18 +1204,19 @@ with block:
                     6, # gpu_memory_preservation
                     False, # enable_preview
                     False, # use_teacache
-                    16 # mp4_crf
+                    16, # mp4_crf
+                    30 # fps_number
                 ]
             ],
         run_on_click = True,
         fn = process,
 	    inputs = ips,
-        outputs = [result_video, preview_image, progress_desc, progress_bar, start_button, end_button],
+        outputs = [result_video, preview_image, progress_desc, progress_bar, start_button, end_button, warning],
         cache_examples = False,
     )
 
     gr.Examples(
-        label = "Examples from image",
+        label = "🖼️ Examples from image",
         examples = [
                 [
                     "./img_examples/Example1.png", # input_image
@@ -1188,6 +1226,8 @@ with block:
                     "Missing arm, unrealistic position, impossible contortion, visible bone, muscle contraction, blurred, blurry", # n_prompt
                     True, # randomize_seed
                     42, # seed
+                    True, # auto_allocation
+                    180, # allocation_time
                     672, # resolution
                     1, # total_second_length
                     9, # latent_window_size
@@ -1198,7 +1238,8 @@ with block:
                     6, # gpu_memory_preservation
                     False, # enable_preview
                     True, # use_teacache
-                    16 # mp4_crf
+                    16, # mp4_crf
+                    30 # fps_number
                 ],
                 [
                     "./img_examples/Example2.webp", # input_image
@@ -1208,6 +1249,8 @@ with block:
                     "Missing arm, unrealistic position, impossible contortion, visible bone, muscle contraction, blurred, blurry", # n_prompt
                     True, # randomize_seed
                     42, # seed
+                    True, # auto_allocation
+                    180, # allocation_time
                     672, # resolution
                     2, # total_second_length
                     9, # latent_window_size
@@ -1218,7 +1261,8 @@ with block:
                     6, # gpu_memory_preservation
                     False, # enable_preview
                     True, # use_teacache
-                    16 # mp4_crf
+                    16, # mp4_crf
+                    30 # fps_number
                 ],
                 [
                     "./img_examples/Example2.webp", # input_image
@@ -1228,6 +1272,8 @@ with block:
                     "Missing arm, unrealistic position, impossible contortion, visible bone, muscle contraction, blurred, blurry", # n_prompt
                     True, # randomize_seed
                     42, # seed
+                    True, # auto_allocation
+                    180, # allocation_time
                     672, # resolution
                     2, # total_second_length
                     9, # latent_window_size
@@ -1238,7 +1284,8 @@ with block:
                     6, # gpu_memory_preservation
                     False, # enable_preview
                     True, # use_teacache
-                    16 # mp4_crf
+                    16, # mp4_crf
+                    30 # fps_number
                 ],
                 [
                     "./img_examples/Example3.jpg", # input_image
@@ -1248,6 +1295,8 @@ with block:
                     "Missing arm, unrealistic position, impossible contortion, visible bone, muscle contraction, blurred, blurry", # n_prompt
                     True, # randomize_seed
                     42, # seed
+                    True, # auto_allocation
+                    180, # allocation_time
                     672, # resolution
                     1, # total_second_length
                     9, # latent_window_size
@@ -1258,7 +1307,8 @@ with block:
                     6, # gpu_memory_preservation
                     False, # enable_preview
                     True, # use_teacache
-                    16 # mp4_crf
+                    16, # mp4_crf
+                    30 # fps_number
                 ],
                 [
                     "./img_examples/Example4.webp", # input_image
@@ -1268,6 +1318,8 @@ with block:
                     "Missing arm, unrealistic position, impossible contortion, visible bone, muscle contraction, blurred, blurry", # n_prompt
                     True, # randomize_seed
                     42, # seed
+                    True, # auto_allocation
+                    180, # allocation_time
                     672, # resolution
                     1, # total_second_length
                     9, # latent_window_size
@@ -1278,18 +1330,19 @@ with block:
                     6, # gpu_memory_preservation
                     False, # enable_preview
                     False, # use_teacache
-                    16 # mp4_crf
+                    16, # mp4_crf
+                    30 # fps_number
                 ]
             ],
         run_on_click = True,
         fn = process,
 	    inputs = ips,
-        outputs = [result_video, preview_image, progress_desc, progress_bar, start_button, end_button],
+        outputs = [result_video, preview_image, progress_desc, progress_bar, start_button, end_button, warning],
         cache_examples = False,
     )
 
     gr.Examples(
-        label = "Examples from video",
+        label = "🎥 Examples from video",
         examples = [
                 [
                     "./img_examples/Example1.mp4", # input_video
@@ -1297,6 +1350,8 @@ with block:
                     "Missing arm, unrealistic position, impossible contortion, visible bone, muscle contraction, blurred, blurry", # n_prompt
                     True, # randomize_seed
                     42, # seed
+                    True, # auto_allocation
+                    180, # allocation_time
                     1, # batch
                     672, # resolution
                     1, # total_second_length
@@ -1317,7 +1372,7 @@ with block:
         run_on_click = True,
         fn = process_video,
 	    inputs = ips_video,
-	    outputs = [result_video, preview_image, progress_desc, progress_bar, start_button_video, end_button],
+	    outputs = [result_video, preview_image, progress_desc, progress_bar, start_button_video, end_button, warning],
         cache_examples = False,
     )
 
@@ -1343,11 +1398,11 @@ with block:
     
     def handle_generation_mode_change(generation_mode_data):
         if generation_mode_data == "text":
-            return [gr.update(visible = True), gr.update(visible = False), gr.update(visible = False), gr.update(visible = False), gr.update(visible = True), gr.update(visible = False), gr.update(visible = False), gr.update(visible = False), gr.update(visible = False), gr.update(visible = False), gr.update(visible = False)]
+            return [gr.update(visible = True), gr.update(visible = False), gr.update(visible = False), gr.update(visible = False), gr.update(visible = True), gr.update(visible = False), gr.update(visible = False), gr.update(visible = False), gr.update(visible = False), gr.update(visible = False), gr.update(visible = False), gr.update(visible = True)]
         elif generation_mode_data == "image":
-            return [gr.update(visible = False), gr.update(visible = True), gr.update(visible = True), gr.update(visible = False), gr.update(visible = True), gr.update(visible = False), gr.update(visible = False), gr.update(visible = False), gr.update(visible = False), gr.update(visible = False), gr.update(visible = False)]
+            return [gr.update(visible = False), gr.update(visible = True), gr.update(visible = True), gr.update(visible = False), gr.update(visible = True), gr.update(visible = False), gr.update(visible = False), gr.update(visible = False), gr.update(visible = False), gr.update(visible = False), gr.update(visible = False), gr.update(visible = True)]
         elif generation_mode_data == "video":
-            return [gr.update(visible = False), gr.update(visible = False), gr.update(visible = False), gr.update(visible = True), gr.update(visible = False), gr.update(visible = True), gr.update(visible = True), gr.update(visible = True), gr.update(visible = True), gr.update(visible = True), gr.update(visible = True)]
+            return [gr.update(visible = False), gr.update(visible = False), gr.update(visible = False), gr.update(visible = True), gr.update(visible = False), gr.update(visible = True), gr.update(visible = True), gr.update(visible = True), gr.update(visible = True), gr.update(visible = True), gr.update(visible = True), gr.update(visible = False)]
 
     prompt_number.change(fn=handle_prompt_number_change, inputs=[], outputs=[])
     timeless_prompt.change(fn=handle_timeless_prompt_change, inputs=[timeless_prompt], outputs=[final_prompt])
@@ -1369,7 +1424,7 @@ with block:
     generation_mode.change(
         fn=handle_generation_mode_change,
         inputs=[generation_mode],
-        outputs=[text_to_video_hint, image_position, input_image, input_video, start_button, start_button_video, no_resize, batch, num_clean_frames, vae_batch, prompt_hint]
+        outputs=[text_to_video_hint, image_position, input_image, input_video, start_button, start_button_video, no_resize, batch, num_clean_frames, vae_batch, prompt_hint, fps_number]
     )
 
     # Update display when the page loads
@@ -1377,7 +1432,7 @@ with block:
         fn=handle_generation_mode_change, inputs = [
         generation_mode
     ], outputs = [
-       text_to_video_hint, image_position, input_image, input_video, start_button, start_button_video, no_resize, batch, num_clean_frames, vae_batch, prompt_hint
+       text_to_video_hint, image_position, input_image, input_video, start_button, start_button_video, no_resize, batch, num_clean_frames, vae_batch, prompt_hint, fps_number
     ]
     )