80 -> 60

app_v2v.py

@@ -46,48 +46,48 @@ from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, Hunyuan
 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}')
-    
-    
-    
+
+
+
     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()
     tokenizer = LlamaTokenizerFast.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer')
     tokenizer_2 = CLIPTokenizer.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer_2')
     vae = AutoencoderKLHunyuanVideo.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='vae', torch_dtype=torch.float16).cpu()
-    
+
     feature_extractor = SiglipImageProcessor.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='feature_extractor')
     image_encoder = SiglipVisionModel.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='image_encoder', torch_dtype=torch.float16).cpu()
-    
+
     transformer = HunyuanVideoTransformer3DModelPacked.from_pretrained('lllyasviel/FramePack_F1_I2V_HY_20250503', torch_dtype=torch.bfloat16).cpu()
-    
+
     vae.eval()
     text_encoder.eval()
     text_encoder_2.eval()
     image_encoder.eval()
     transformer.eval()
-    
+
     if not high_vram:
         vae.enable_slicing()
         vae.enable_tiling()
-    
+
     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)
     image_encoder.to(dtype=torch.float16)
     text_encoder.to(dtype=torch.float16)
     text_encoder_2.to(dtype=torch.float16)
-    
+
     vae.requires_grad_(False)
     text_encoder.requires_grad_(False)
     text_encoder_2.requires_grad_(False)
     image_encoder.requires_grad_(False)
     transformer.requires_grad_(False)
-    
+
     if not high_vram:
         # DynamicSwapInstaller is same as huggingface's enable_sequential_offload but 3x faster
         DynamicSwapInstaller.install_model(transformer, device=gpu)
@@ -104,23 +104,21 @@ stream = AsyncStream()
 outputs_folder = './outputs/'
 os.makedirs(outputs_folder, exist_ok=True)
 
-input_video_debug_value = None
-prompt_debug_value = None
-total_second_length_debug_value = None
+input_image_debug_value = prompt_debug_value = total_second_length_debug_value = None
 
 @spaces.GPU()
 @torch.no_grad()
 def video_encode(video_path, resolution, no_resize, vae, vae_batch_size=16, device="cuda", width=None, height=None):
     """
     Encode a video into latent representations using the VAE.
-    
+
     Args:
         video_path: Path to the input video file.
         vae: AutoencoderKLHunyuanVideo model.
         height, width: Target resolution for resizing frames.
         vae_batch_size: Number of frames to process per batch.
         device: Device for computation (e.g., "cuda").
-    
+
     Returns:
         start_latent: Latent of the first frame (for compatibility with original code).
         input_image_np: First frame as numpy array (for CLIP vision encoding).
@@ -159,11 +157,11 @@ def video_encode(video_path, resolution, no_resize, vae, vae_batch_size=16, devi
         # 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}")
-    
+
         # 20250506 pftq: Use native resolution if height/width not specified, otherwise use provided values
         target_height = native_height if height is None else height
         target_width = native_width if width is None else width
-    
+
         # 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)
@@ -190,7 +188,7 @@ def video_encode(video_path, resolution, no_resize, vae, vae_batch_size=16, devi
         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}")
-        
+
         # 20250507 pftq: Save pixel frames for use in worker
         input_video_pixels = frames_pt.cpu()
 
@@ -229,7 +227,7 @@ def video_encode(video_path, resolution, no_resize, vae, vae_batch_size=16, devi
                     if device == "cuda" and "out of memory" in str(e).lower():
                         print("CUDA out of memory, try reducing vae_batch_size or using CPU")
                     raise
-        
+
         # 20250506 pftq: Concatenate latents
         print("Concatenating latents...")
         history_latents = torch.cat(latents, dim=2)  # Shape: (1, channels, frames, height//8, width//8)
@@ -256,15 +254,15 @@ def set_mp4_comments_imageio_ffmpeg(input_file, comments):
     try:
         # Get the path to the bundled FFmpeg binary from imageio-ffmpeg
         ffmpeg_path = imageio_ffmpeg.get_ffmpeg_exe()
-        
+
         # Check if input file exists
         if not os.path.exists(input_file):
             print(f"Error: Input file {input_file} does not exist")
             return False
-            
+
         # Create a temporary file path
         temp_file = tempfile.NamedTemporaryFile(suffix='.mp4', delete=False).name
-        
+
         # FFmpeg command using the bundled binary
         command = [
             ffmpeg_path,                   # Use imageio-ffmpeg's FFmpeg
@@ -275,10 +273,10 @@ def set_mp4_comments_imageio_ffmpeg(input_file, comments):
             '-y',                          # overwrite output file if it exists
             temp_file                      # temporary output file
         ]
-        
+
         # Run the FFmpeg command
         result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-        
+
         if result.returncode == 0:
             # Replace the original file with the modified one
             shutil.move(temp_file, input_file)
@@ -290,7 +288,7 @@ def set_mp4_comments_imageio_ffmpeg(input_file, comments):
                 os.remove(temp_file)
             print(f"Error: FFmpeg failed with message:\n{result.stderr}")
             return False
-            
+
     except Exception as e:
         # Clean up temp file in case of other errors
         if 'temp_file' in locals() and os.path.exists(temp_file):
@@ -301,8 +299,8 @@ def set_mp4_comments_imageio_ffmpeg(input_file, comments):
 # 20250506 pftq: Modified worker to accept video input and clean frame count
 @spaces.GPU()
 @torch.no_grad()
-def worker(input_video, prompt, n_prompt, seed, batch, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch):
-    
+def worker_video(input_video, prompt, n_prompt, seed, batch, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch):
+
     stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Starting ...'))))
 
     try:
@@ -338,7 +336,7 @@ def worker(input_video, prompt, n_prompt, seed, batch, resolution, total_second_
         #start_latent, input_image_np, history_latents, fps = video_encode(input_video, vae, height, width, vae_batch_size=16, device=gpu)
         start_latent, input_image_np, video_latents, fps, height, width, input_video_pixels  = video_encode(input_video, resolution, no_resize, vae, vae_batch_size=vae_batch, device=gpu)
 
-        #Image.fromarray(input_image_np).save(os.path.join(outputs_folder, f'{job_id}.png')) 
+        #Image.fromarray(input_image_np).save(os.path.join(outputs_folder, f'{job_id}.png'))
 
         # CLIP Vision
         stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'CLIP Vision encoding ...'))))
@@ -362,60 +360,60 @@ def worker(input_video, prompt, n_prompt, seed, batch, resolution, total_second_
         for idx in range(batch):
             if batch > 1:
                 print(f"Beginning video {idx+1} of {batch} with seed {seed} ")
-            
+
             #job_id = generate_timestamp()
             job_id = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")+f"_framepackf1-videoinput_{width}-{total_second_length}sec_seed-{seed}_steps-{steps}_distilled-{gs}_cfg-{cfg}" # 20250506 pftq: easier to read timestamp and filename
-            
+
             # Sampling
             stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Start sampling ...'))))
-    
+
             rnd = torch.Generator("cpu").manual_seed(seed)
-    
+
             # 20250506 pftq: Initialize history_latents with video latents
             history_latents = video_latents.cpu()
             total_generated_latent_frames = history_latents.shape[2]
             # 20250506 pftq: Initialize history_pixels to fix UnboundLocalError
             history_pixels = None
             previous_video = None
-            
+
             # 20250507 pftq: hot fix for initial video being corrupted by vae encoding, issue with ghosting because of slight differences
-            #history_pixels = input_video_pixels 
+            #history_pixels = input_video_pixels
             #save_bcthw_as_mp4(vae_decode(video_latents, vae).cpu(), os.path.join(outputs_folder, f'{job_id}_input_video.mp4'), fps=fps, crf=mp4_crf) # 20250507 pftq: test fast movement corrupted by vae encoding if vae batch size too low
-            
+
             for section_index in range(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 not high_vram:
                     unload_complete_models()
                     move_model_to_device_with_memory_preservation(transformer, target_device=gpu, preserved_memory_gb=gpu_memory_preservation)
-    
+
                 if use_teacache:
                     transformer.initialize_teacache(enable_teacache=True, num_steps=steps)
                 else:
                     transformer.initialize_teacache(enable_teacache=False)
-    
+
                 def callback(d):
                     preview = d['denoised']
                     preview = vae_decode_fake(preview)
-    
+
                     preview = (preview * 255.0).detach().cpu().numpy().clip(0, 255).astype(np.uint8)
                     preview = einops.rearrange(preview, 'b c t h w -> (b h) (t w) c')
-    
+
                     if stream.input_queue.top() == 'end':
                         stream.output_queue.push(('end', None))
                         raise KeyboardInterrupt('User ends the task.')
-    
+
                     current_step = d['i'] + 1
                     percentage = int(100.0 * current_step / steps)
                     hint = f'Sampling {current_step}/{steps}'
                     desc = f'Total frames: {int(max(0, total_generated_latent_frames * 4 - 3))}, Video length: {max(0, (total_generated_latent_frames * 4 - 3) / fps) :.2f} seconds (FPS-{fps}), Seed: {seed}, Video {idx+1} of {batch}. The video is generating part {section_index+1} of {total_latent_sections}...'
                     stream.output_queue.push(('progress', (preview, desc, make_progress_bar_html(percentage, hint))))
                     return
-    
+
                 # 20250506 pftq: Use user-specified number of context frames, matching original allocation for num_clean_frames=2
                 available_frames = history_latents.shape[2]  # Number of latent frames
                 max_pixel_frames = min(latent_window_size * 4 - 3, available_frames * 4)  # Cap at available pixel frames
@@ -425,7 +423,7 @@ def worker(input_video, prompt, n_prompt, seed, batch, resolution, total_second_
                 effective_clean_frames = min(effective_clean_frames, available_frames - 2) if available_frames > 2 else 0 # 20250507 pftq: changed 1 to 2 for edge case for <=1 sec videos
                 num_2x_frames = min(2, max(1, available_frames - effective_clean_frames - 1)) if available_frames > effective_clean_frames + 1 else 0 # 20250507 pftq: subtracted 1 for edge case for <=1 sec videos
                 num_4x_frames = min(16, max(1, available_frames - effective_clean_frames - num_2x_frames)) if available_frames > effective_clean_frames + num_2x_frames else 0 # 20250507 pftq: Edge case for <=1 sec
-                
+
                 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
 
@@ -434,12 +432,12 @@ def worker(input_video, prompt, n_prompt, seed, batch, resolution, total_second_
                     [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
                 )
                 clean_latent_indices = torch.cat([clean_latent_indices_start, clean_latent_1x_indices], dim=1)
-    
+
                 # 20250506 pftq: Split history_latents dynamically based on available frames
                 fallback_frame_count = 2 # 20250507 pftq: Changed 0 to 2 Edge case for <=1 sec videos
-                context_frames = history_latents[:, :, -total_context_frames:, :, :] if total_context_frames > 0 else history_latents[:, :, :fallback_frame_count, :, :]  
+                context_frames = history_latents[:, :, -total_context_frames:, :, :] if total_context_frames > 0 else history_latents[:, :, :fallback_frame_count, :, :]
                 if total_context_frames > 0:
-                    split_sizes = [num_4x_frames, num_2x_frames, effective_clean_frames] 
+                    split_sizes = [num_4x_frames, num_2x_frames, effective_clean_frames]
                     split_sizes = [s for s in split_sizes if s > 0]  # Remove zero sizes
                     if split_sizes:
                         splits = context_frames.split(split_sizes, dim=2)
@@ -452,12 +450,12 @@ def worker(input_video, prompt, n_prompt, seed, batch, resolution, total_second_
                         if clean_latents_2x.shape[2] < 2:  # 20250507 pftq: edge case for <=1 sec videos
                             clean_latents_2x = torch.cat([clean_latents_2x, clean_latents_2x[:, :, -1:, :, :]], dim=2)[:, :, :2, :, :]
                         split_idx += 1 if num_2x_frames > 0 else 0
-                        clean_latents_1x = splits[split_idx] if effective_clean_frames > 0 and split_idx < len(splits) else history_latents[:, :, :fallback_frame_count, :, :] 
+                        clean_latents_1x = splits[split_idx] if effective_clean_frames > 0 and split_idx < len(splits) else history_latents[:, :, :fallback_frame_count, :, :]
                     else:
-                        clean_latents_4x = clean_latents_2x = clean_latents_1x = history_latents[:, :, :fallback_frame_count, :, :] 
+                        clean_latents_4x = clean_latents_2x = clean_latents_1x = history_latents[:, :, :fallback_frame_count, :, :]
                 else:
-                    clean_latents_4x = clean_latents_2x = clean_latents_1x = history_latents[:, :, :fallback_frame_count, :, :] 
-    
+                    clean_latents_4x = clean_latents_2x = clean_latents_1x = history_latents[:, :, :fallback_frame_count, :, :]
+
                 clean_latents = torch.cat([start_latent.to(history_latents), clean_latents_1x], dim=2)
 
                 # 20250507 pftq: Fix for <=1 sec videos.
@@ -492,42 +490,42 @@ def worker(input_video, prompt, n_prompt, seed, batch, resolution, total_second_
                     clean_latent_4x_indices=clean_latent_4x_indices,
                     callback=callback,
                 )
-    
+
                 total_generated_latent_frames += int(generated_latents.shape[2])
                 history_latents = torch.cat([history_latents, generated_latents.to(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)
-    
+
                 real_history_latents = history_latents[:, :, -total_generated_latent_frames:, :, :]
-    
+
                 if history_pixels is None:
                     history_pixels = vae_decode(real_history_latents, vae).cpu()
                 else:
                   section_latent_frames = latent_window_size * 2
                   overlapped_frames = min(latent_window_size * 4 - 3, history_pixels.shape[2])
-                  
-                  #if section_index == 0: 
+
+                  #if section_index == 0:
                     #extra_latents = 1  # Add up to 2 extra latent frames for smoother overlap to initial video
                     #extra_pixel_frames = extra_latents * 4  # Approx. 4 pixel frames per latent
                     #overlapped_frames = min(overlapped_frames + extra_pixel_frames, history_pixels.shape[2], section_latent_frames * 4)
 
                   current_pixels = vae_decode(real_history_latents[:, :, -section_latent_frames:], vae).cpu()
                   history_pixels = soft_append_bcthw(history_pixels, current_pixels, overlapped_frames)
-    
+
                 if not high_vram:
                     unload_complete_models()
-    
+
                 output_filename = os.path.join(outputs_folder, f'{job_id}_{total_generated_latent_frames}.mp4')
-    
+
                 # 20250506 pftq: Use input video FPS for output
                 save_bcthw_as_mp4(history_pixels, output_filename, fps=fps, crf=mp4_crf)
                 print(f"Latest video saved: {output_filename}")
                 # 20250508 pftq: Save prompt to mp4 metadata comments
                 set_mp4_comments_imageio_ffmpeg(output_filename, f"Prompt: {prompt} | Negative Prompt: {n_prompt}");
                 print(f"Prompt saved to mp4 metadata comments: {output_filename}")
-    
+
                 # 20250506 pftq: Clean up previous partial files
                 if previous_video is not None and os.path.exists(previous_video):
                     try:
@@ -536,9 +534,9 @@ def worker(input_video, prompt, n_prompt, seed, batch, resolution, total_second_
                     except Exception as e:
                         print(f"Error deleting previous partial video {previous_video}: {e}")
                 previous_video = output_filename
-    
+
                 print(f'Decoded. Current latent shape {real_history_latents.shape}; pixel shape {history_pixels.shape}')
-    
+
                 stream.output_queue.push(('file', output_filename))
 
             seed = (seed + 1) % np.iinfo(np.int32).max
@@ -553,16 +551,16 @@ def worker(input_video, prompt, n_prompt, seed, batch, resolution, total_second_
 
     stream.output_queue.push(('end', None))
     return
-    
-def get_duration(input_video, prompt, n_prompt, randomize_seed, seed, batch, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch):
+
+def get_duration_video(input_video, prompt, n_prompt, randomize_seed, seed, batch, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch):
     global total_second_length_debug_value
     if total_second_length_debug_value is not None:
-        return min(total_second_length_debug_value * 60 * 2, 600)
-    return total_second_length * 60 * 2
+        return min(total_second_length_debug_value * 60 * 10, 600)
+    return total_second_length * 60 * 10
 
 # 20250506 pftq: Modified process to pass clean frame count, etc from video_encode
-@spaces.GPU(duration=get_duration)
-def process(input_video, prompt, n_prompt, randomize_seed, seed, batch, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch):
+@spaces.GPU(duration=get_duration_video)
+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, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch):
     global stream, high_vram, input_video_debug_value, prompt_debug_value, total_second_length_debug_value
 
     if torch.cuda.device_count() == 0:
@@ -601,11 +599,11 @@ def process(input_video, prompt, n_prompt, randomize_seed, seed, batch, resoluti
     # 20250508 pftq: automatically set distilled cfg to 1 if cfg is used
     if cfg > 1:
         gs = 1
-    
+
     stream = AsyncStream()
 
     # 20250506 pftq: Pass num_clean_frames, vae_batch, etc
-    async_run(worker, input_video, prompt, n_prompt, seed, batch, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch)
+    async_run(worker_video, input_video, prompt, n_prompt, seed, batch, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch)
 
     output_filename = None
 
@@ -628,11 +626,6 @@ def process(input_video, prompt, n_prompt, randomize_seed, seed, batch, resoluti
 def end_process():
     stream.input_queue.push('end')
 
-quick_prompts = [
-    'The girl dances gracefully, with clear movements, full of charm.',
-    'A character doing some simple body movements.',
-]
-quick_prompts = [[x] for x in quick_prompts]
 
 css = make_progress_bar_css()
 block = gr.Blocks(css=css).queue()
@@ -641,23 +634,25 @@ with block:
         with gr.Row():
             gr.HTML("""
     <p style="background-color: red;"><big><big><big><b>⚠️To use FramePack, <a href="https://huggingface.co/spaces/Fabrice-TIERCELIN/SUPIR?duplicate=true">duplicate this space</a> and set a GPU with 30 GB VRAM.</b>
-    
+
     You can't use FramePack directly here because this space runs on a CPU, which is not enough for FramePack. Please provide <a href="https://huggingface.co/spaces/Fabrice-TIERCELIN/SUPIR/discussions/new">feedback</a> if you have issues.
     </big></big></big></p>
     """)
     # 20250506 pftq: Updated title to reflect video input functionality
     gr.Markdown('# Framepack F1 with Image Input or with Video Input (Video Extension)')
+    gr.Markdown(f"""### Video diffusion, but feels like image diffusion
+*FramePack F1 - a FramePack model that only predicts future frames from history frames*
+### *beta* FramePack Fill 🖋️- draw a mask over the input image to inpaint the video output
+adapted from the officical code repo [FramePack](https://github.com/lllyasviel/FramePack) by [lllyasviel](lllyasviel/FramePack_F1_I2V_HY_20250503) and [FramePack Studio](https://github.com/colinurbs/FramePack-Studio) 🙌🏻
+    """)
     with gr.Row():
         with gr.Column():
-            # 20250506 pftq: Changed to Video input from Image
             input_video = gr.Video(sources='upload', label="Input Video", height=320)
             prompt = gr.Textbox(label="Prompt", value='')
-            #example_quick_prompts = gr.Dataset(samples=quick_prompts, label='Quick List', samples_per_page=1000, components=[prompt])
-            #example_quick_prompts.click(lambda x: x[0], inputs=[example_quick_prompts], outputs=prompt, show_progress=False, queue=False)
 
             with gr.Row():
-                start_button = gr.Button(value="Start Generation")
-                end_button = gr.Button(value="End Generation", interactive=False)
+                start_button = gr.Button(value="Start Generation", variant="primary")
+                end_button = gr.Button(value="End Generation", variant="stop", interactive=False)
 
             with gr.Accordion("Advanced settings", open=False):
                 with gr.Row():
@@ -672,33 +667,33 @@ with block:
                 resolution = gr.Number(label="Resolution (max width or height)", value=640, precision=0, visible=False)
 
                 total_second_length = gr.Slider(label="Additional Video Length to Generate (Seconds)", minimum=1, maximum=120, value=5, step=0.1)
-                
+
                 # 20250506 pftq: Reduced default distilled guidance scale to improve adherence to input video
                 gs = gr.Slider(label="Distilled CFG Scale", minimum=1.0, maximum=32.0, value=3.0, step=0.01, info='Prompt adherence at the cost of less details from the input video, but to a lesser extent than Context Frames.')
                 cfg = gr.Slider(label="CFG Scale", minimum=1.0, maximum=32.0, value=1.0, step=0.01, visible=True, info='Use this instead of Distilled for more detail/control + Negative Prompt (make sure Distilled set to 1). Doubles render time.')  # Should not change
                 rs = gr.Slider(label="CFG Re-Scale", minimum=0.0, maximum=1.0, value=0.0, step=0.01, visible=False)  # Should not change
 
-                n_prompt = gr.Textbox(label="Negative Prompt", value="", visible=True, info='Requires using normal CFG (undistilled) instead of Distilled (set Distilled=1 and CFG > 1).') 
+                n_prompt = gr.Textbox(label="Negative Prompt", value="", visible=True, info='Requires using normal CFG (undistilled) instead of Distilled (set Distilled=1 and CFG > 1).')
                 steps = gr.Slider(label="Steps", minimum=1, maximum=100, value=25, step=1, info='Increase for more quality, especially if using high non-distilled CFG.')
 
                 # 20250506 pftq: Renamed slider to Number of Context Frames and updated description
                 num_clean_frames = gr.Slider(label="Number of Context Frames", minimum=2, maximum=10, value=5, step=1, info="Retain more video details but increase memory use. Reduce to 2 if memory issues.")
-                
+
                 default_vae = 32
                 if high_vram:
                     default_vae = 128
                 elif free_mem_gb>=20:
                     default_vae = 64
-                    
+
                 vae_batch = gr.Slider(label="VAE Batch Size for Input Video", minimum=4, maximum=256, value=default_vae, step=4, info="Reduce if running out of memory. Increase for better quality frames during fast motion.")
 
-                latent_window_size = gr.Slider(label="Latent Window Size", minimum=9, maximum=33, value=9, step=1, visible=True, info='Generate more frames at a time (larger chunks). Less degradation and better blending but higher VRAM cost.') 
+                latent_window_size = gr.Slider(label="Latent Window Size", minimum=9, maximum=33, value=9, step=1, visible=True, info='Generate more frames at a time (larger chunks). Less degradation and better blending but higher VRAM cost.')
 
                 gpu_memory_preservation = gr.Slider(label="GPU Inference Preserved Memory (GB) (larger means slower)", minimum=6, maximum=128, value=6, step=0.1, info="Set this number to a larger value if you encounter OOM. Larger value causes slower speed.")
 
                 mp4_crf = gr.Slider(label="MP4 Compression", minimum=0, maximum=100, value=16, step=1, info="Lower means better quality. 0 is uncompressed. Change to 16 if you get black outputs. ")
 
-            with gr.Row():
+            with gr.Accordion("Debug", open=False):
                 input_video_debug = gr.Video(sources='upload', label="Input Video Debug", height=320)
                 prompt_debug = gr.Textbox(label="Prompt Debug", value='')
                 total_second_length_debug = gr.Slider(label="Additional Video Length to Generate (Seconds) Debug", minimum=1, maximum=120, value=1, step=0.1)
@@ -735,19 +730,19 @@ with block:
                 ],
             ],
         run_on_click = True,
-        fn = process,
+        fn = process_video,
 	    inputs = [input_video, prompt, n_prompt, randomize_seed, seed, batch, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch],
 	    outputs = [result_video, preview_image, progress_desc, progress_bar, start_button, end_button],
         cache_examples = True,
     )
 
-    gr.HTML("""
-        <div style="text-align:center; margin-top:20px;">Share your results and find ideas at the <a href="https://x.com/search?q=framepack&f=live" target="_blank">FramePack Twitter (X) thread</a></div>
-    """)
+    gr.Markdown('## Guide')
+    gr.Markdown("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.")
+
 
     # 20250506 pftq: Updated inputs to include num_clean_frames
     ips = [input_video, prompt, n_prompt, randomize_seed, seed, batch, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch]
-    start_button.click(fn=process, inputs=ips, outputs=[result_video, preview_image, progress_desc, progress_bar, start_button, end_button])
+    start_button.click(fn=process_video, inputs=ips, outputs=[result_video, preview_image, progress_desc, progress_bar, start_button, end_button])
     end_button.click(fn=end_process)