This Pull Request also extends a video & optimizes time & VRAM

.gitattributes

@@ -36,3 +36,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 img_examples/1.png filter=lfs diff=lfs merge=lfs -text
 img_examples/2.jpg filter=lfs diff=lfs merge=lfs -text
 img_examples/3.png filter=lfs diff=lfs merge=lfs -text
+img_examples/Example1.mp4 filter=lfs diff=lfs merge=lfs -text
+img_examples/Example1.png filter=lfs diff=lfs merge=lfs -text
+img_examples/Example2.webp filter=lfs diff=lfs merge=lfs -text
+img_examples/Example3.jpg filter=lfs diff=lfs merge=lfs -text
+img_examples/Example4.webp filter=lfs diff=lfs merge=lfs -text

README.md

@@ -4,11 +4,19 @@ emoji: 📹⚡️
 colorFrom: pink
 colorTo: gray
 sdk: gradio
-sdk_version: 5.32.0
-app_file: app.py
 pinned: true
+sdk_version: 5.29.1
+app_file: app.py
 license: apache-2.0
-short_description: fast video generation from images & text
+short_description: Text-to-Video/Image-to-Video/Video extender (timed prompt)
+tags:
+  - Image-to-Video
+  - Image-2-Video
+  - Img-to-Vid
+  - Img-2-Vid
+  - language models
+  - LLMs
+suggested_hardware: zero-a10g
 ---
 paper: arxiv:2504.12626
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -4,14 +4,32 @@ import os
 
 os.environ['HF_HOME'] = os.path.abspath(os.path.realpath(os.path.join(os.path.dirname(__file__), './hf_download')))
 
+try:
+    import spaces
+except:
+    print("Not on HuggingFace")
 import gradio as gr
 import torch
 import traceback
 import einops
 import safetensors.torch as sf
 import numpy as np
+import random
+import time
 import math
-import spaces
+# 20250506 pftq: Added for video input loading
+import decord
+# 20250506 pftq: Added for progress bars in video_encode
+from tqdm import tqdm
+# 20250506 pftq: Normalize file paths for Windows compatibility
+import pathlib
+# 20250506 pftq: for easier to read timestamp
+from datetime import datetime
+# 20250508 pftq: for saving prompt to mp4 comments metadata
+import imageio_ffmpeg
+import tempfile
+import shutil
+import subprocess
 
 from PIL import Image
 from diffusers import AutoencoderKLHunyuanVideo
@@ -20,131 +38,299 @@ from diffusers_helper.hunyuan import encode_prompt_conds, vae_decode, vae_encode
 from diffusers_helper.utils import save_bcthw_as_mp4, crop_or_pad_yield_mask, soft_append_bcthw, resize_and_center_crop, state_dict_weighted_merge, state_dict_offset_merge, generate_timestamp
 from diffusers_helper.models.hunyuan_video_packed import HunyuanVideoTransformer3DModelPacked
 from diffusers_helper.pipelines.k_diffusion_hunyuan import sample_hunyuan
-from diffusers_helper.memory import cpu, gpu, get_cuda_free_memory_gb, move_model_to_device_with_memory_preservation, offload_model_from_device_for_memory_preservation, fake_diffusers_current_device, DynamicSwapInstaller, unload_complete_models, load_model_as_complete
+if torch.cuda.device_count() > 0:
+    from diffusers_helper.memory import cpu, gpu, get_cuda_free_memory_gb, move_model_to_device_with_memory_preservation, offload_model_from_device_for_memory_preservation, fake_diffusers_current_device, DynamicSwapInstaller, unload_complete_models, load_model_as_complete
 from diffusers_helper.thread_utils import AsyncStream, async_run
 from diffusers_helper.gradio.progress_bar import make_progress_bar_css, make_progress_bar_html
 from transformers import SiglipImageProcessor, SiglipVisionModel
 from diffusers_helper.clip_vision import hf_clip_vision_encode
 from diffusers_helper.bucket_tools import find_nearest_bucket
+from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, HunyuanVideoTransformer3DModel, HunyuanVideoPipeline
+import pillow_heif
 
+pillow_heif.register_heif_opener()
 
-free_mem_gb = get_cuda_free_memory_gb(gpu)
-high_vram = free_mem_gb > 60
+high_vram = False
+free_mem_gb = 0
 
-print(f'Free VRAM {free_mem_gb} GB')
-print(f'High-VRAM Mode: {high_vram}')
+if torch.cuda.device_count() > 0:
+    free_mem_gb = get_cuda_free_memory_gb(gpu)
+    high_vram = free_mem_gb > 60
 
-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)
-    DynamicSwapInstaller.install_model(text_encoder, device=gpu)
-else:
-    text_encoder.to(gpu)
-    text_encoder_2.to(gpu)
-    image_encoder.to(gpu)
-    vae.to(gpu)
-    transformer.to(gpu)
+    #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)
+        DynamicSwapInstaller.install_model(text_encoder, device=gpu)
+    else:
+        text_encoder.to(gpu)
+        text_encoder_2.to(gpu)
+        image_encoder.to(gpu)
+        vae.to(gpu)
+        transformer.to(gpu)
 
 stream = AsyncStream()
 
 outputs_folder = './outputs/'
 os.makedirs(outputs_folder, exist_ok=True)
 
-examples = [
-["img_examples/1.png", "The girl dances gracefully, with clear movements, full of charm.",],
-["img_examples/2.jpg", "The man dances flamboyantly, swinging his hips and striking bold poses with dramatic flair."],
-["img_examples/3.png", "The woman dances elegantly among the blossoms, spinning slowly with flowing sleeves and graceful hand movements."],
-]
+default_local_storage = {
+        "generation-mode": "image",
+    }
 
-def generate_examples(input_image, prompt):
-    
-    t2v=False 
-    n_prompt=""
-    seed=31337
-    total_second_length=5 
-    latent_window_size=9 
-    steps=25 
-    cfg=1.0 
-    gs=10.0 
-    rs=0.0
-    gpu_memory_preservation=6 
-    use_teacache=True 
-    mp4_crf=16
-
-    global stream
-    
-    # assert input_image is not None, 'No input image!'
-    if t2v:
-        default_height, default_width = 640, 640
-        input_image = np.ones((default_height, default_width, 3), dtype=np.uint8) * 255
-        print("No input image provided. Using a blank white image.") 
-
-    yield None, None, '', '', gr.update(interactive=False), gr.update(interactive=True)
-
-    stream = AsyncStream()
-
-    async_run(worker, input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, mp4_crf)
-
-    output_filename = None
+@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).
+        history_latents: Latents of all frames (shape: [1, channels, frames, height//8, width//8]).
+        fps: Frames per second of the input video.
+    """
+    # 20250506 pftq: Normalize video path for Windows compatibility
+    video_path = str(pathlib.Path(video_path).resolve())
+    #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")
+        device = "cpu"
 
-    while True:
-        flag, data = stream.output_queue.next()
+    try:
+        # 20250506 pftq: Load video and get FPS
+        #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}")
+
+        # 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")
+        num_real_frames = num_frames
+
+        # 20250506 pftq: Read 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}")
+
+        # 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)
+            #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 = []
+        for i, frame in enumerate(frames):
+            #print(f"Preprocessing frame {i+1}/{num_frames}")
+            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}")
+
+        # 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...")
+        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}")
+
+        # 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}")
+        frames_pt = frames_pt.to(device)
+        #print("Tensor moved to device")
+
+        # 20250506 pftq: Move VAE to device
+        #print(f"Moving VAE to device: {device}")
+        vae.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)")
+        latents = []
+        vae.eval()
+        with torch.no_grad():
+            for i in tqdm(range(0, frames_pt.shape[2], vae_batch_size), desc="Encoding video frames", mininterval=0.1):
+                #print(f"Encoding batch {i//vae_batch_size + 1}: frames {i} to {min(i + vae_batch_size, frames_pt.shape[2])}")
+                batch = frames_pt[:, :, i:i + vae_batch_size]  # Shape: (1, channels, batch_size, height, width)
+                try:
+                    # 20250506 pftq: Log GPU memory before encoding
+                    if device == "cuda":
+                        free_mem = torch.cuda.memory_allocated() / 1024**3
+                        #print(f"GPU memory before encoding: {free_mem:.2f} GB")
+                    batch_latent = vae_encode(batch, vae)
+                    # 20250506 pftq: Synchronize CUDA to catch issues
+                    if device == "cuda":
+                        torch.cuda.synchronize()
+                        #print(f"GPU memory after encoding: {torch.cuda.memory_allocated() / 1024**3:.2f} GB")
+                    latents.append(batch_latent)
+                    #print(f"Batch encoded, latent shape: {batch_latent.shape}")
+                except RuntimeError as e:
+                    print(f"Error during VAE encoding: {str(e)}")
+                    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)
+        #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}")
+
+        # 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")
+
+        return start_latent, input_image_np, history_latents, fps, target_height, target_width, input_video_pixels
+
+    except Exception as e:
+        print(f"Error in video_encode: {str(e)}")
+        raise
+
+# 20250508 pftq: for saving prompt to mp4 metadata comments
+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
+            '-i', input_file,              # input file
+            '-metadata', f'comment={comments}',  # set comment metadata
+            '-c:v', 'copy',                # copy video stream without re-encoding
+            '-c:a', 'copy',                # copy audio stream without re-encoding
+            '-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)
+            #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}")
+            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):
+            os.remove(temp_file)
+        print(f"Error saving prompt to video metadata, ffmpeg may be required: "+str(e))
+        return False
 
-        if flag == 'file':
-            output_filename = data
-            yield output_filename, gr.update(), gr.update(), gr.update(), gr.update(interactive=False), gr.update(interactive=True)
+@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, 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)
 
-        if flag == 'progress':
-            preview, desc, html = data
-            yield gr.update(), gr.update(visible=True, value=preview), desc, html, gr.update(interactive=False), gr.update(interactive=True)
+        if cfg == 1:
+            llama_vec_n, clip_l_pooler_n = torch.zeros_like(llama_vec), torch.zeros_like(clip_l_pooler)
+        else:
+            llama_vec_n, clip_l_pooler_n = encode_prompt_conds(n_prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)
 
-        if flag == 'end':
-            yield output_filename, gr.update(visible=False), gr.update(), '', gr.update(interactive=True), gr.update(interactive=False)
-            break
+        llama_vec, llama_attention_mask = crop_or_pad_yield_mask(llama_vec, length=512)
+        llama_vec_n, llama_attention_mask_n = crop_or_pad_yield_mask(llama_vec_n, length=512)
 
+        llama_vec = llama_vec.to(transformer.dtype)
+        llama_vec_n = llama_vec_n.to(transformer.dtype)
+        clip_l_pooler = clip_l_pooler.to(transformer.dtype)
+        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]
 
-    
-@torch.no_grad()
-def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, mp4_crf):
-    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 ...'))))
@@ -164,54 +350,60 @@ def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_wind
             fake_diffusers_current_device(text_encoder, gpu)  # since we only encode one text - that is one model move and one encode, offload is same time consumption since it is also one load and one encode.
             load_model_as_complete(text_encoder_2, target_device=gpu)
 
-        llama_vec, clip_l_pooler = encode_prompt_conds(prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)
+        prompt_parameters = []
 
-        if cfg == 1:
-            llama_vec_n, clip_l_pooler_n = torch.zeros_like(llama_vec), torch.zeros_like(clip_l_pooler)
-        else:
-            llama_vec_n, clip_l_pooler_n = encode_prompt_conds(n_prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)
+        for prompt_part in prompts[:total_latent_sections]:
+            prompt_parameters.append(encode_prompt(prompt_part, n_prompt))
 
-        llama_vec, llama_attention_mask = crop_or_pad_yield_mask(llama_vec, length=512)
-        llama_vec_n, llama_attention_mask_n = crop_or_pad_yield_mask(llama_vec_n, length=512)
+        # 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 ...'))))
 
         H, W, C = input_image.shape
-        height, width = find_nearest_bucket(H, W, resolution=640)
-        input_image_np = resize_and_center_crop(input_image, target_width=width, target_height=height)
-
-        Image.fromarray(input_image_np).save(os.path.join(outputs_folder, f'{job_id}.png'))
-
-        input_image_pt = torch.from_numpy(input_image_np).float() / 127.5 - 1
-        input_image_pt = input_image_pt.permute(2, 0, 1)[None, :, None]
-
-        # VAE encoding
-
-        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'VAE encoding ...'))))
-
-        if not high_vram:
-            load_model_as_complete(vae, target_device=gpu)
-
-        start_latent = vae_encode(input_image_pt, vae)
-
-        # CLIP Vision
-
-        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'CLIP Vision encoding ...'))))
-
-        if not high_vram:
-            load_model_as_complete(image_encoder, target_device=gpu)
+        height, width = find_nearest_bucket(H, W, resolution=resolution)
+        
+        def get_start_latent(input_image, height, width, vae, gpu, image_encoder, high_vram):
+            input_image_np = resize_and_center_crop(input_image, target_width=width, target_height=height)
+            
+            #Image.fromarray(input_image_np).save(os.path.join(outputs_folder, f'{job_id}.png'))
+            
+            input_image_pt = torch.from_numpy(input_image_np).float() / 127.5 - 1
+            input_image_pt = input_image_pt.permute(2, 0, 1)[None, :, None]
+            
+            # VAE encoding
+            
+            stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'VAE encoding ...'))))
+            
+            if not high_vram:
+                load_model_as_complete(vae, target_device=gpu)
+            
+            start_latent = vae_encode(input_image_pt, vae)
+            
+            # CLIP Vision
+            
+            stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'CLIP Vision encoding ...'))))
+            
+            if not high_vram:
+                unload_complete_models(vae)
+                load_model_as_complete(image_encoder, target_device=gpu)
 
-        image_encoder_output = hf_clip_vision_encode(input_image_np, feature_extractor, image_encoder)
-        image_encoder_last_hidden_state = image_encoder_output.last_hidden_state
+            image_encoder_last_hidden_state = hf_clip_vision_encode(input_image_np, feature_extractor, image_encoder).last_hidden_state
+            
+            if not high_vram:
+                unload_complete_models(image_encoder)
+                
+            return [start_latent, image_encoder_last_hidden_state]
+            
+        [start_latent, image_encoder_last_hidden_state] = get_start_latent(input_image, height, width, vae, gpu, image_encoder, high_vram)
 
         # Dtype
 
-        llama_vec = llama_vec.to(transformer.dtype)
-        llama_vec_n = llama_vec_n.to(transformer.dtype)
-        clip_l_pooler = clip_l_pooler.to(transformer.dtype)
-        clip_l_pooler_n = clip_l_pooler_n.to(transformer.dtype)
         image_encoder_last_hidden_state = image_encoder_last_hidden_state.to(transformer.dtype)
 
         # Sampling
@@ -221,51 +413,106 @@ def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_wind
         rnd = torch.Generator("cpu").manual_seed(seed)
 
         history_latents = torch.zeros(size=(1, 16, 16 + 2 + 1, height // 8, width // 8), dtype=torch.float32).cpu()
+        start_latent = start_latent.to(history_latents)
         history_pixels = None
 
-        history_latents = torch.cat([history_latents, start_latent.to(history_latents)], dim=2)
+        history_latents = torch.cat([history_latents, start_latent] if forward else [start_latent, history_latents], dim=2)
         total_generated_latent_frames = 1
 
-        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)
-
+        if enable_preview:
             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 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). 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)
+        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(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([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 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 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(text_encoder, text_encoder_2, image_encoder, vae, transformer)
+
+            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=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]
+        
+        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}')
+
+            prompt_index = min(section_index, len(prompt_parameters) - 1)
 
-            clean_latents_4x, clean_latents_2x, clean_latents_1x = history_latents[:, :, -sum([16, 2, 1]):, :, :].split([16, 2, 1], dim=2)
-            clean_latents = torch.cat([start_latent.to(history_latents), clean_latents_1x], dim=2)
+            [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()
+                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)
+
+            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,
@@ -298,34 +545,305 @@ def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_wind
                 callback=callback,
             )
 
-            total_generated_latent_frames += int(generated_latents.shape[2])
-            history_latents = torch.cat([history_latents, generated_latents.to(history_latents)], dim=2)
+            [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()
 
-            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 not high_vram:
+            unload_complete_models(
+                text_encoder, text_encoder_2, image_encoder, vae, transformer
+            )
 
-            real_history_latents = history_latents[:, :, -total_generated_latent_frames:, :, :]
+    stream.output_queue.push(('end', None))
+    return
 
-            if history_pixels is None:
-                history_pixels = vae_decode(real_history_latents, vae).cpu()
-            else:
-                section_latent_frames = latent_window_size * 2
-                overlapped_frames = latent_window_size * 4 - 3
+# 20250506 pftq: Modified worker to accept video input and clean frame count
+@torch.no_grad()
+def worker_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):
+    def encode_prompt(prompt, n_prompt):
+        llama_vec, clip_l_pooler = encode_prompt_conds(prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)
+
+        if cfg == 1:
+            llama_vec_n, clip_l_pooler_n = torch.zeros_like(llama_vec), torch.zeros_like(clip_l_pooler)
+        else:
+            llama_vec_n, clip_l_pooler_n = encode_prompt_conds(n_prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)
 
-                current_pixels = vae_decode(real_history_latents[:, :, -section_latent_frames:], vae).cpu()
-                history_pixels = soft_append_bcthw(history_pixels, current_pixels, overlapped_frames)
+        llama_vec, llama_attention_mask = crop_or_pad_yield_mask(llama_vec, length=512)
+        llama_vec_n, llama_attention_mask_n = crop_or_pad_yield_mask(llama_vec_n, length=512)
 
-            if not high_vram:
-                unload_complete_models()
+        llama_vec = llama_vec.to(transformer.dtype)
+        llama_vec_n = llama_vec_n.to(transformer.dtype)
+        clip_l_pooler = clip_l_pooler.to(transformer.dtype)
+        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]
+
+    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(
+                text_encoder, text_encoder_2, image_encoder, vae, transformer
+            )
+
+        # Text encoding
+        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Text encoding ...'))))
+
+        if not high_vram:
+            fake_diffusers_current_device(text_encoder, gpu)  # since we only encode one text - that is one model move and one encode, offload is same time consumption since it is also one load and one encode.
+            load_model_as_complete(text_encoder_2, target_device=gpu)
+
+        prompt_parameters = []
+
+        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
+            )
+
+        # CLIP Vision
+        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'CLIP Vision encoding ...'))))
+
+        if not high_vram:
+            load_model_as_complete(image_encoder, target_device=gpu)
+
+        image_encoder_output = hf_clip_vision_encode(input_image_np, feature_extractor, image_encoder)
+
+        # Clean GPU
+        if not high_vram:
+            unload_complete_models(image_encoder)
 
-            output_filename = os.path.join(outputs_folder, f'{job_id}_{total_generated_latent_frames}.mp4')
+        image_encoder_last_hidden_state = image_encoder_output.last_hidden_state
+
+        # Dtype
+        image_encoder_last_hidden_state = image_encoder_last_hidden_state.to(transformer.dtype)
+
+        if enable_preview:
+            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}), Resolution: {height}px * {width}px, 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
+        else:
+            def callback(d):
+                return
 
-            save_bcthw_as_mp4(history_pixels, output_filename, fps=30, crf=mp4_crf)
+        def compute_latent(history_latents, latent_window_size, num_clean_frames, start_latent):
+            # 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
+            adjusted_latent_frames = max(1, (max_pixel_frames + 3) // 4)  # Convert back to latent frames
+            # Adjust num_clean_frames to match original behavior: num_clean_frames=2 means 1 frame for clean_latents_1x
+            effective_clean_frames = max(0, num_clean_frames - 1)
+            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
+
+            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
+            )
+            clean_latent_indices = torch.cat([clean_latent_indices_start, clean_latent_1x_indices], dim=1)
 
-            print(f'Decoded. Current latent shape {real_history_latents.shape}; pixel shape {history_pixels.shape}')
+            # 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 = clean_latents_4x = clean_latents_2x = clean_latents_1x = history_latents[:, :, :fallback_frame_count, :, :]
+
+            if total_context_frames > 0:
+                context_frames = history_latents[:, :, -total_context_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)
+                    split_idx = 0
+                    
+                    if num_4x_frames > 0:
+                        clean_latents_4x = splits[split_idx]
+                        split_idx = 1
+                    if clean_latents_4x.shape[2] < 2:  # 20250507 pftq: edge case for <=1 sec videos
+                        print("Edge case for <=1 sec videos 4x")
+                        clean_latents_4x = clean_latents_4x.expand(-1, -1, 2, -1, -1)
+                        
+                    if num_2x_frames > 0 and split_idx < len(splits):
+                        clean_latents_2x = splits[split_idx]
+                        if clean_latents_2x.shape[2] < 2:  # 20250507 pftq: edge case for <=1 sec videos
+                            print("Edge case for <=1 sec videos 2x")
+                            clean_latents_2x = clean_latents_2x.expand(-1, -1, 2, -1, -1)
+                        split_idx += 1
+                    elif clean_latents_2x.shape[2] < 2:  # 20250507 pftq: edge case for <=1 sec videos
+                        clean_latents_2x = clean_latents_4x
+                        
+                    if effective_clean_frames > 0 and split_idx < len(splits):
+                        clean_latents_1x = splits[split_idx]
+
+            clean_latents = torch.cat([start_latent, clean_latents_1x], dim=2)
+
+            # 20250507 pftq: Fix for <=1 sec videos.
+            max_frames = min(latent_window_size * 4 - 3, history_latents.shape[2] * 4)
+            return [max_frames, clean_latents, clean_latents_2x, clean_latents_4x, latent_indices, clean_latents, clean_latent_indices, clean_latent_2x_indices, clean_latent_4x_indices]
+
+        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
+            total_generated_latent_frames = history_latents.shape[2]
+            # 20250506 pftq: Initialize history_pixels to fix UnboundLocalError
+            history_pixels = None
+            previous_video = None
+
+            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 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(0)
+
+                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)
+
+                [max_frames, clean_latents, clean_latents_2x, clean_latents_4x, latent_indices, clean_latents, clean_latent_indices, clean_latent_2x_indices, clean_latent_4x_indices] = compute_latent(history_latents, latent_window_size, num_clean_frames, start_latent)
+
+                generated_latents = sample_hunyuan(
+                    transformer=transformer,
+                    sampler='unipc',
+                    width=width,
+                    height=height,
+                    frames=max_frames,
+                    real_guidance_scale=cfg,
+                    distilled_guidance_scale=gs,
+                    guidance_rescale=rs,
+                    num_inference_steps=steps,
+                    generator=rnd,
+                    prompt_embeds=llama_vec,
+                    prompt_embeds_mask=llama_attention_mask,
+                    prompt_poolers=clip_l_pooler,
+                    negative_prompt_embeds=llama_vec_n,
+                    negative_prompt_embeds_mask=llama_attention_mask_n,
+                    negative_prompt_poolers=clip_l_pooler_n,
+                    device=gpu,
+                    dtype=torch.bfloat16,
+                    image_embeddings=image_encoder_last_hidden_state,
+                    latent_indices=latent_indices,
+                    clean_latents=clean_latents,
+                    clean_latent_indices=clean_latent_indices,
+                    clean_latents_2x=clean_latents_2x,
+                    clean_latent_2x_indices=clean_latent_2x_indices,
+                    clean_latents_4x=clean_latents_4x,
+                    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)
+
+                if history_pixels is None:
+                    real_history_latents = 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 = min(latent_window_size * 4 - 3, history_pixels.shape[2])
+
+                    real_history_latents = history_latents[:, :, -min(total_generated_latent_frames, section_latent_frames):, :, :]
+                    history_pixels = soft_append_bcthw(history_pixels, vae_decode(real_history_latents, vae).cpu(), overlapped_frames)
+
+                if not high_vram:
+                    unload_complete_models(text_encoder, text_encoder_2, image_encoder, vae, transformer)
+
+                if enable_preview or section_index == total_latent_sections - 1:
+                    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: {prompts} | 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:
+                            os.remove(previous_video)
+                            print(f"Previous partial video deleted: {previous_video}")
+                        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
 
-            stream.output_queue.push(('file', output_filename))
     except:
         traceback.print_exc()
 
@@ -337,62 +855,122 @@ def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_wind
     stream.output_queue.push(('end', None))
     return
 
-def get_duration(input_image, prompt, t2v, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, mp4_crf):
-    return total_second_length * 60
+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(input_image, prompt, 
-            t2v=False, 
-            n_prompt="", 
-            seed=31337, 
-            total_second_length=5, 
-            latent_window_size=9, 
-            steps=25, 
-            cfg=1.0, 
-            gs=10.0, 
-            rs=0.0, 
-            gpu_memory_preservation=6, 
-            use_teacache=True, 
-            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, fps_number)
+
+    output_filename = None
+
+    while True:
+        flag, data = stream.output_queue.next()
+
+        if flag == 'file':
+            output_filename = data
+            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.skip()
+
+        if flag == 'end':
+            end = time.time()
+            secondes = int(end - start)
+            minutes = math.floor(secondes / 60)
+            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.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. " + \
+            "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(input_image,
+            image_position=0,
+            prompt="",
+            generation_mode="image",
+            n_prompt="",
+            randomize_seed=True,
+            seed=31337,
+            auto_allocation=True,
+            allocation_time=180,
+            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,
+            fps_number=30
+           ):
+    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.skip(), gr.skip(), gr.skip(), gr.skip(), gr.skip(), gr.skip(), gr.update(visible = False)
+        return
+
+    if randomize_seed:
+        seed = random.randint(0, np.iinfo(np.int32).max)
+
+    prompts = prompt.split(";")
+
     # assert input_image is not None, 'No input image!'
-    if t2v:
+    if generation_mode == "text":
         default_height, default_width = 640, 640
         input_image = np.ones((default_height, default_width, 3), dtype=np.uint8) * 255
         print("No input image provided. Using a blank white image.")
-    else:
-        composite_rgba_uint8 = input_image["composite"] 
-
-        # rgb_uint8 will be (H, W, 3), dtype uint8
-        rgb_uint8 = composite_rgba_uint8[:, :, :3]
-        # mask_uint8 will be (H, W), dtype uint8
-        mask_uint8 = composite_rgba_uint8[:, :, 3]
-    
-        # Create background
-        h, w = rgb_uint8.shape[:2]
-        # White background, (H, W, 3), dtype uint8
-        background_uint8 = np.full((h, w, 3), 255, dtype=np.uint8) 
-        
-        # Normalize mask to range [0.0, 1.0]. 
-        alpha_normalized_float32 = mask_uint8.astype(np.float32) / 255.0
-        
-        # Expand alpha to 3 channels to match RGB images for broadcasting.
-        # alpha_mask_float32 will have shape (H, W, 3)
-        alpha_mask_float32 = np.stack([alpha_normalized_float32] * 3, axis=2)
-        
-        # alpha blending
-        blended_image_float32 = rgb_uint8.astype(np.float32) * alpha_mask_float32 + \
-                                background_uint8.astype(np.float32) * (1.0 - alpha_mask_float32)
-
-        input_image = np.clip(blended_image_float32, 0, 255).astype(np.uint8)
-    
-    yield None, None, '', '', gr.update(interactive=False), gr.update(interactive=True)
 
+    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,
+            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
+           )
+
+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, 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()
 
-    async_run(worker, input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, mp4_crf)
+    # 20250506 pftq: Pass num_clean_frames, vae_batch, etc
+    async_run(worker_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)
 
     output_filename = None
 
@@ -401,88 +979,479 @@ def process(input_image, prompt,
 
         if flag == 'file':
             output_filename = data
-            yield output_filename, gr.update(), gr.update(), gr.update(), gr.update(interactive=False), gr.update(interactive=True)
+            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(), gr.update(visible=True, value=preview), desc, html, gr.update(interactive=False), gr.update(interactive=True)
+            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':
-            yield output_filename, gr.update(visible=False), gr.update(), '', gr.update(interactive=True), gr.update(interactive=False)
+            end = time.time()
+            secondes = int(end - start)
+            minutes = math.floor(secondes / 60)
+            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), desc + \
+            " The process has lasted " + \
+            ((str(hours) + " h, ") if hours != 0 else "") + \
+            ((str(minutes) + " min, ") if hours != 0 or minutes != 0 else "") + \
+            str(secondes) + " sec. " + \
+            " 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, 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 * (2.5 if use_teacache else 3.5) * (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.skip(), gr.skip(), gr.skip(), gr.skip(), gr.skip(), gr.skip(), gr.update(visible = False)
+        return
+
+    if randomize_seed:
+        seed = random.randint(0, np.iinfo(np.int32).max)
+
+    prompts = prompt.split(";")
+
+    # 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.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):
+        print("Disabling high vram mode due to no resize and/or potentially higher resolution...")
+        high_vram = False
+        vae.enable_slicing()
+        vae.enable_tiling()
+        DynamicSwapInstaller.install_model(transformer, device=gpu)
+        DynamicSwapInstaller.install_model(text_encoder, device=gpu)
+
+    # 20250508 pftq: automatically set distilled cfg to 1 if cfg is used
+    if cfg > 1:
+        gs = 1
+
+    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')
 
+timeless_prompt_value = [""]
+timed_prompts = {}
+
+def handle_prompt_number_change():
+    timed_prompts.clear()
+    return []
+
+def handle_timeless_prompt_change(timeless_prompt):
+    timeless_prompt_value[0] = timeless_prompt
+    return refresh_prompt()
 
-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]
+def handle_timed_prompt_change(timed_prompt_id, timed_prompt):
+    timed_prompts[timed_prompt_id] = timed_prompt
+    return refresh_prompt()
 
+def refresh_prompt():
+    dict_values = {k: v for k, v in timed_prompts.items()}
+    sorted_dict_values = sorted(dict_values.items(), key=lambda x: x[0])
+    array = []
+    for sorted_dict_value in sorted_dict_values:
+        if timeless_prompt_value[0] is not None and len(timeless_prompt_value[0]) and sorted_dict_value[1] is not None and len(sorted_dict_value[1]):
+            array.append(timeless_prompt_value[0] + ". " + sorted_dict_value[1])
+        else:
+            array.append(timeless_prompt_value[0] + sorted_dict_value[1])
+    print(str(array))
+    return ";".join(array)
+
+title_html = """
+    <h1><center>FramePack</center></h1>
+    <big><center>Generate videos from text/image/video freely, without account, without watermark and download it</center></big>
+    <br/>
+    
+    <p>This space is ready to work on ZeroGPU and GPU and has been tested successfully on ZeroGPU. Please leave a <a href="https://huggingface.co/spaces/Fabrice-TIERCELIN/FramePack/discussions/new">message in discussion</a> if you encounter issues.</p>
+    """
+
+js = """
+function createGradioAnimation() {
+    window.addEventListener("beforeunload", function(e) {
+        if (document.getElementById('end-button') && !document.getElementById('end-button').disabled) {
+            var confirmationMessage = 'A process is still running. '
+                                    + 'If you leave before saving, your changes will be lost.';
+    
+            (e || window.event).returnValue = confirmationMessage;
+        }
+        return confirmationMessage;
+    });
+    return 'Animation created';
+}
+"""
 
 css = make_progress_bar_css()
-block = gr.Blocks(css=css).queue()
+block = gr.Blocks(css=css, js=js).queue()
 with block:
-    gr.Markdown('# FramePack-F1')
-    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) 🙌🏻
+    if torch.cuda.device_count() == 0:
+        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/FramePack?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/FramePack/discussions/new">feedback</a> if you have issues.
+    </big></big></big></p>
     """)
+    gr.HTML(title_html)
+    local_storage = gr.BrowserState(default_local_storage)
     with gr.Row():
         with gr.Column():
-            input_image = gr.ImageEditor(type="numpy", label="Image", height=320, brush=gr.Brush(colors=["#ffffff"]))
-            prompt = gr.Textbox(label="Prompt", value='')
-            t2v = gr.Checkbox(label="do text-to-video", value=False)
-            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)
+            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("Text-to-Video badly works with a flash effect at the start. 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=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')
+
+            @gr.render(inputs=prompt_number)
+            def show_split(prompt_number):
+                for digit in range(prompt_number):
+                    timed_prompt_id = gr.Textbox(value="timed_prompt_" + str(digit), visible=False)
+                    timed_prompt = gr.Textbox(label="Timed prompt #" + str(digit + 1), elem_id="timed_prompt_" + str(digit), value="")
+                    timed_prompt.change(fn=handle_timed_prompt_change, inputs=[timed_prompt_id, timed_prompt], outputs=[final_prompt])
+
+            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 if 30 fps)", minimum=1, maximum=120, value=2, step=0.1)
 
             with gr.Row():
-                start_button = gr.Button(value="Start Generation")
-                end_button = gr.Button(value="End Generation", interactive=False)
+                start_button = gr.Button(value="🎥 Generate", variant="primary")
+                start_button_video = gr.Button(value="🎥 Generate", variant="primary")
+                end_button = gr.Button(elem_id="end-button", value="End Generation", variant="stop", interactive=False)
 
-            total_second_length = gr.Slider(label="Total Video Length (Seconds)", minimum=1, maximum=5, value=2, step=0.1)
-            with gr.Group():
-                with gr.Accordion("Advanced settings", open=False):
-                    use_teacache = gr.Checkbox(label='Use TeaCache', value=True, info='Faster speed, but often makes hands and fingers slightly worse.')
-    
-                    n_prompt = gr.Textbox(label="Negative Prompt", value="", visible=False)  # Not used
-                    seed = gr.Number(label="Seed", value=31337, precision=0)
-    
-                    
-                    latent_window_size = gr.Slider(label="Latent Window Size", minimum=1, maximum=33, value=9, step=1, visible=False)  # Should not change
-                    steps = gr.Slider(label="Steps", minimum=1, maximum=100, value=25, step=1, info='Changing this value is not recommended.')
-    
-                    cfg = gr.Slider(label="CFG Scale", minimum=1.0, maximum=32.0, value=1.0, step=0.01, visible=False)  # Should not change
-                    gs = gr.Slider(label="Distilled CFG Scale", minimum=1.0, maximum=32.0, value=10.0, step=0.01, info='Changing this value is not recommended.')
-                    rs = gr.Slider(label="CFG Re-Scale", minimum=0.0, maximum=1.0, value=0.0, step=0.01, visible=False)  # Should not change
-    
-                    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.Accordion("Advanced settings", open=False):
+                enable_preview = gr.Checkbox(label='Enable preview', value=True, info='Display a preview around each second generated but it costs 2 sec. for each second generated.')
+                use_teacache = gr.Checkbox(label='Use TeaCache', value=False, info='Faster speed and no break in brightness, but often makes hands and fingers slightly worse.')
+
+                n_prompt = gr.Textbox(label="Negative Prompt", value="Missing arm, long hand, 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.')
+
+                with gr.Row():
+                    no_resize = gr.Checkbox(label='Force Original Video Resolution (no Resizing)', value=False, info='Might run out of VRAM (720p requires > 24GB VRAM).')
+                    resolution = gr.Dropdown([
+                        ["409,600 px (working)", 640],
+                        ["451,584 px (working)", 672],
+                        ["495,616 px (VRAM pb on HF)", 704],
+                        ["589,824 px (not tested)", 768],
+                        ["692,224 px (not tested)", 832],
+                        ["746,496 px (not tested)", 864],
+                        ["921,600 px (not tested)", 960]
+                    ], value=672, label="Resolution (width x height)", info="Do not affect the generation time")
+
+                # 20250506 pftq: Reduced default distilled guidance scale to improve adherence to input video
+                cfg = gr.Slider(label="CFG Scale", minimum=1.0, maximum=32.0, value=1.0, step=0.01, info='Use this instead of Distilled for more detail/control + Negative Prompt (make sure Distilled set to 1). Doubles render time. Should not change.')
+                gs = gr.Slider(label="Distilled CFG Scale", minimum=1.0, maximum=32.0, value=10.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; 3=follow the prompt but blurred motions & unsharped, 10=focus motion; changing this value is not recommended')
+                rs = gr.Slider(label="CFG Re-Scale", minimum=0.0, maximum=1.0, value=0.0, step=0.01, info='Should not change')
+
+
+                # 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 to avoid memory issues or to give more weight to the prompt.")
+
+                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.")
+
+
+                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. ")
+                batch = gr.Slider(label="Batch Size (Number of Videos)", minimum=1, maximum=1000, value=1, step=1, info='Generate multiple videos each with a different seed.')
+                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(elem_id="warning", 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)
+            result_video = gr.Video(label="Generated Frames", autoplay=True, show_share_button=False, height=512, loop=True)
             preview_image = gr.Image(label="Next Latents", height=200, visible=False)
-            result_video = gr.Video(label="Finished Frames", autoplay=True, show_share_button=False, height=512, loop=True)
             progress_desc = gr.Markdown('', elem_classes='no-generating-animation')
             progress_bar = gr.HTML('', elem_classes='no-generating-animation')
 
-    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>')
-
-    ips = [input_image, prompt, t2v, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, mp4_crf]
-    start_button.click(fn=process, inputs=ips, outputs=[result_video, preview_image, progress_desc, progress_bar, start_button, end_button])
+    # 20250506 pftq: Updated inputs to include num_clean_frames
+    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",
+        examples = [
+                [
+                    None, # input_image
+                    0, # image_position
+                    "Overcrowed street in Japan, photorealistic, realistic, intricate details, 8k, insanely detailed",
+                    "text", # generation_mode
+                    "Missing arm, long hand, 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
+                    30, # steps
+                    1.0, # cfg
+                    10.0, # gs
+                    0.0, # rs
+                    6, # gpu_memory_preservation
+                    False, # enable_preview
+                    False, # use_teacache
+                    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, warning],
+        cache_examples = False,
+    )
+
+    gr.Examples(
+        label = "🖼️ Examples from image",
+        examples = [
+                [
+                    "./img_examples/Example1.png", # input_image
+                    0, # image_position
+                    "A dolphin emerges from the water, photorealistic, realistic, intricate details, 8k, insanely detailed",
+                    "image", # generation_mode
+                    "Missing arm, long hand, 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
+                    30, # steps
+                    1.0, # cfg
+                    10.0, # gs
+                    0.0, # rs
+                    6, # gpu_memory_preservation
+                    False, # enable_preview
+                    True, # use_teacache
+                    16, # mp4_crf
+                    30 # fps_number
+                ],
+                [
+                    "./img_examples/Example2.webp", # input_image
+                    0, # image_position
+                    "A man on the left and a woman on the right face each other ready to start a conversation, large space between the persons, full view, full-length view, 3D, pixar, 3D render, CGI. The man talks and the woman listens; A man on the left and a woman on the right face each other ready to start a conversation, large space between the persons, full view, full-length view, 3D, pixar, 3D render, CGI. The woman talks, the man stops talking and the man listens; A man on the left and a woman on the right face each other ready to start a conversation, large space between the persons, full view, full-length view, 3D, pixar, 3D render, CGI. The woman talks and the man listens",
+                    "image", # generation_mode
+                    "Missing arm, long hand, 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
+                    30, # steps
+                    1.0, # cfg
+                    10.0, # gs
+                    0.0, # rs
+                    6, # gpu_memory_preservation
+                    False, # enable_preview
+                    True, # use_teacache
+                    16, # mp4_crf
+                    30 # fps_number
+                ],
+                [
+                    "./img_examples/Example2.webp", # input_image
+                    0, # image_position
+                    "A man on the left and a woman on the right face each other ready to start a conversation, large space between the persons, full view, full-length view, 3D, pixar, 3D render, CGI. The woman talks and the man listens; A man on the left and a woman on the right face each other ready to start a conversation, large space between the persons, full view, full-length view, 3D, pixar, 3D render, CGI. The man talks, the woman stops talking and the woman listens A man on the left and a woman on the right face each other ready to start a conversation, large space between the persons, full view, full-length view, 3D, pixar, 3D render, CGI. The man talks and the woman listens",
+                    "image", # generation_mode
+                    "Missing arm, long hand, 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
+                    30, # steps
+                    1.0, # cfg
+                    10.0, # gs
+                    0.0, # rs
+                    6, # gpu_memory_preservation
+                    False, # enable_preview
+                    True, # use_teacache
+                    16, # mp4_crf
+                    30 # fps_number
+                ],
+                [
+                    "./img_examples/Example3.jpg", # input_image
+                    0, # image_position
+                    "A boy is walking to the right, full view, full-length view, cartoon",
+                    "image", # generation_mode
+                    "Missing arm, long hand, 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
+                    30, # steps
+                    1.0, # cfg
+                    10.0, # gs
+                    0.0, # rs
+                    6, # gpu_memory_preservation
+                    False, # enable_preview
+                    True, # use_teacache
+                    16, # mp4_crf
+                    30 # fps_number
+                ],
+                [
+                    "./img_examples/Example4.webp", # input_image
+                    100, # image_position
+                    "A building starting to explode, photorealistic, realisitc, 8k, insanely detailed",
+                    "image", # generation_mode
+                    "Missing arm, long hand, 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
+                    30, # steps
+                    1.0, # cfg
+                    10.0, # gs
+                    0.0, # rs
+                    6, # gpu_memory_preservation
+                    False, # enable_preview
+                    False, # use_teacache
+                    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, warning],
+        cache_examples = False,
+    )
+
+    gr.Examples(
+        label = "🎥 Examples from video",
+        examples = [
+                [
+                    "./img_examples/Example1.mp4", # input_video
+                    "View of the sea as far as the eye can see, from the seaside, a piece of land is barely visible on the horizon at the middle, the sky is radiant, reflections of the sun in the water, photorealistic, realistic, intricate details, 8k, insanely detailed",
+                    "Missing arm, long hand, 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
+                    9, # latent_window_size
+                    30, # steps
+                    1.0, # cfg
+                    10.0, # gs
+                    0.0, # rs
+                    6, # gpu_memory_preservation
+                    False, # enable_preview
+                    True, # use_teacache
+                    False, # no_resize
+                    16, # mp4_crf
+                    5, # num_clean_frames
+                    default_vae
+                ]
+            ],
+        run_on_click = True,
+        fn = process_video,
+	    inputs = ips_video,
+	    outputs = [result_video, preview_image, progress_desc, progress_bar, start_button_video, end_button, warning],
+        cache_examples = False,
+    )
+
+    def save_preferences(preferences, value):
+        preferences["generation-mode"] = value
+        return preferences
+    
+    def load_preferences(saved_prefs):
+        saved_prefs = init_preferences(saved_prefs)
+        return saved_prefs["generation-mode"]
+    
+    def init_preferences(saved_prefs):
+        if saved_prefs is None:
+            saved_prefs = default_local_storage
+        return saved_prefs
+    
+    def check_parameters(generation_mode, input_image, input_video):
+        if generation_mode == "image" and input_image is None:
+            raise gr.Error("Please provide an image to extend.")
+        if generation_mode == "video" and input_video is None:
+            raise gr.Error("Please provide a video to extend.")
+        return [gr.update(interactive=True), gr.update(visible = True)]
+    
+    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), 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), 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), 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])
+    start_button.click(fn = check_parameters, inputs = [
+        generation_mode, input_image, input_video
+    ], outputs = [end_button, warning], queue = False, show_progress = False).success(fn=process, inputs=ips, outputs=[result_video, preview_image, progress_desc, progress_bar, start_button, end_button, warning], scroll_to_output = True)
+    start_button_video.click(fn = check_parameters, inputs = [
+        generation_mode, input_image, input_video
+    ], outputs = [end_button, warning], queue = False, show_progress = False).success(fn=process_video, inputs=ips_video, outputs=[result_video, preview_image, progress_desc, progress_bar, start_button_video, end_button, warning], scroll_to_output = True)
     end_button.click(fn=end_process)
 
-    # gr.Examples(
-    #     examples,
-    #     inputs=[input_image, prompt],
-    #     outputs=[result_video, preview_image, progress_desc, progress_bar, start_button, end_button],
-    #     fn=generate_examples,
-    #     cache_examples=True
-    #     )
-
-
-block.launch(share=True, mcp_server=True)
+    generation_mode.change(fn = save_preferences, inputs = [
+        local_storage,
+        generation_mode,
+    ], outputs = [
+       local_storage
+    ])
+
+    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, fps_number]
+    )
+
+    # Update display when the page loads
+    block.load(
+        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, fps_number
+    ]
+    )
+
+    # Load saved preferences when the page loads
+    block.load(
+        fn=load_preferences, inputs = [
+        local_storage
+    ], outputs = [
+       generation_mode
+    ]
+    )
+
+block.launch(mcp_server=True, ssr_mode=False)

app_endframe.py

@@ -0,0 +1,822 @@
+from diffusers_helper.hf_login import login
+
+import os
+
+os.environ['HF_HOME'] = os.path.abspath(os.path.realpath(os.path.join(os.path.dirname(__file__), './hf_download')))
+
+import gradio as gr
+import torch
+import traceback
+import einops
+import safetensors.torch as sf
+import numpy as np
+import argparse
+import random
+import math
+# 20250506 pftq: Added for video input loading
+import decord
+# 20250506 pftq: Added for progress bars in video_encode
+from tqdm import tqdm
+# 20250506 pftq: Normalize file paths for Windows compatibility
+import pathlib
+# 20250506 pftq: for easier to read timestamp
+from datetime import datetime
+# 20250508 pftq: for saving prompt to mp4 comments metadata
+import imageio_ffmpeg
+import tempfile
+import shutil
+import subprocess
+import spaces
+from PIL import Image
+from diffusers import AutoencoderKLHunyuanVideo
+from transformers import LlamaModel, CLIPTextModel, LlamaTokenizerFast, CLIPTokenizer
+from diffusers_helper.hunyuan import encode_prompt_conds, vae_decode, vae_encode, vae_decode_fake
+from diffusers_helper.utils import save_bcthw_as_mp4, crop_or_pad_yield_mask, soft_append_bcthw, resize_and_center_crop, state_dict_weighted_merge, state_dict_offset_merge, generate_timestamp
+from diffusers_helper.models.hunyuan_video_packed import HunyuanVideoTransformer3DModelPacked
+from diffusers_helper.pipelines.k_diffusion_hunyuan import sample_hunyuan
+from diffusers_helper.memory import cpu, gpu, get_cuda_free_memory_gb, move_model_to_device_with_memory_preservation, offload_model_from_device_for_memory_preservation, fake_diffusers_current_device, DynamicSwapInstaller, unload_complete_models, load_model_as_complete
+from diffusers_helper.thread_utils import AsyncStream, async_run
+from diffusers_helper.gradio.progress_bar import make_progress_bar_css, make_progress_bar_html
+from transformers import SiglipImageProcessor, SiglipVisionModel
+from diffusers_helper.clip_vision import hf_clip_vision_encode
+from diffusers_helper.bucket_tools import find_nearest_bucket
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--share', action='store_true')
+parser.add_argument("--server", type=str, default='0.0.0.0')
+parser.add_argument("--port", type=int, required=False)
+parser.add_argument("--inbrowser", action='store_true')
+args = parser.parse_args()
+
+print(args)
+
+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/FramePackI2V_HY', 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)
+    DynamicSwapInstaller.install_model(text_encoder, device=gpu)
+else:
+    text_encoder.to(gpu)
+    text_encoder_2.to(gpu)
+    image_encoder.to(gpu)
+    vae.to(gpu)
+    transformer.to(gpu)
+
+stream = AsyncStream()
+
+outputs_folder = './outputs/'
+os.makedirs(outputs_folder, exist_ok=True)
+
+# 20250506 pftq: Added function to encode input video frames into latents
+@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).
+        history_latents: Latents of all frames (shape: [1, channels, frames, height//8, width//8]).
+        fps: Frames per second of the input video.
+    """
+    # 20250506 pftq: Normalize video path for Windows compatibility
+    video_path = str(pathlib.Path(video_path).resolve())
+    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")
+        device = "cpu"
+
+    try:
+        # 20250506 pftq: Load video and get FPS
+        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}")
+
+        # 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")
+        num_real_frames = num_frames
+
+        # 20250506 pftq: Read 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}")
+
+        # 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)
+            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 = []
+        for i, frame in enumerate(frames):
+            #print(f"Preprocessing frame {i+1}/{num_frames}")
+            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}")
+
+        # 20250506 pftq: Save first frame for CLIP vision encoding
+        input_image_np = processed_frames[0]
+        end_of_input_video_image_np = processed_frames[-1]
+
+        # 20250506 pftq: Convert to tensor and normalize to [-1, 1]
+        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}")
+        
+        # 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}")
+        frames_pt = frames_pt.to(device)
+        print("Tensor moved to device")
+
+        # 20250506 pftq: Move VAE to device
+        print(f"Moving VAE to device: {device}")
+        vae.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)")
+        latents = []
+        vae.eval()
+        with torch.no_grad():
+            for i in tqdm(range(0, frames_pt.shape[2], vae_batch_size), desc="Encoding video frames", mininterval=0.1):
+                #print(f"Encoding batch {i//vae_batch_size + 1}: frames {i} to {min(i + vae_batch_size, frames_pt.shape[2])}")
+                batch = frames_pt[:, :, i:i + vae_batch_size]  # Shape: (1, channels, batch_size, height, width)
+                try:
+                    # 20250506 pftq: Log GPU memory before encoding
+                    if device == "cuda":
+                        free_mem = torch.cuda.memory_allocated() / 1024**3
+                        #print(f"GPU memory before encoding: {free_mem:.2f} GB")
+                    batch_latent = vae_encode(batch, vae)
+                    # 20250506 pftq: Synchronize CUDA to catch issues
+                    if device == "cuda":
+                        torch.cuda.synchronize()
+                        #print(f"GPU memory after encoding: {torch.cuda.memory_allocated() / 1024**3:.2f} GB")
+                    latents.append(batch_latent)
+                    #print(f"Batch encoded, latent shape: {batch_latent.shape}")
+                except RuntimeError as e:
+                    print(f"Error during VAE encoding: {str(e)}")
+                    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)
+        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)
+        end_of_input_video_latent = history_latents[:, :, -1:]  # Shape: (1, channels, 1, height//8, width//8)
+        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")
+
+        return start_latent, input_image_np, history_latents, fps, target_height, target_width, input_video_pixels, end_of_input_video_latent, end_of_input_video_image_np
+
+    except Exception as e:
+        print(f"Error in video_encode: {str(e)}")
+        raise
+
+    
+# 20250507 pftq: New function to encode a single image (end frame)
+@torch.no_grad()
+def image_encode(image_np, target_width, target_height, vae, image_encoder, feature_extractor, device="cuda"):
+    """
+    Encode a single image into a latent and compute its CLIP vision embedding.
+    
+    Args:
+        image_np: Input image as numpy array.
+        target_width, target_height: Exact resolution to resize the image to (matches start frame).
+        vae: AutoencoderKLHunyuanVideo model.
+        image_encoder: SiglipVisionModel for CLIP vision encoding.
+        feature_extractor: SiglipImageProcessor for preprocessing.
+        device: Device for computation (e.g., "cuda").
+    
+    Returns:
+        latent: Latent representation of the image (shape: [1, channels, 1, height//8, width//8]).
+        clip_embedding: CLIP vision embedding of the image.
+        processed_image_np: Processed image as numpy array (after resizing).
+    """
+    # 20250507 pftq: Process end frame with exact start frame dimensions
+    print("Processing end frame...")
+    try:
+        print(f"Using exact start frame resolution for end frame: {target_width}x{target_height}")
+
+        # Resize and preprocess image to match start frame
+        processed_image_np = resize_and_center_crop(image_np, target_width=target_width, target_height=target_height)
+
+        # Convert to tensor and normalize
+        image_pt = torch.from_numpy(processed_image_np).float() / 127.5 - 1
+        image_pt = image_pt.permute(2, 0, 1).unsqueeze(0).unsqueeze(2)  # Shape: [1, channels, 1, height, width]
+        image_pt = image_pt.to(device)
+
+        # Move VAE to device
+        vae.to(device)
+
+        # Encode to latent
+        latent = vae_encode(image_pt, vae)
+        print(f"image_encode vae output shape: {latent.shape}")
+
+        # Move image encoder to device
+        image_encoder.to(device)
+
+        # Compute CLIP vision embedding
+        clip_embedding = hf_clip_vision_encode(processed_image_np, feature_extractor, image_encoder).last_hidden_state
+
+        # Move models back to CPU and clear cache
+        if device == "cuda":
+            vae.to(cpu)
+            image_encoder.to(cpu)
+            torch.cuda.empty_cache()
+            print("VAE and image encoder moved back to CPU, CUDA cache cleared")
+
+        print(f"End latent shape: {latent.shape}")
+        return latent, clip_embedding, processed_image_np
+
+    except Exception as e:
+        print(f"Error in image_encode: {str(e)}")
+        raise
+        
+# 20250508 pftq: for saving prompt to mp4 metadata comments
+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
+            '-i', input_file,              # input file
+            '-metadata', f'comment={comments}',  # set comment metadata
+            '-c:v', 'copy',                # copy video stream without re-encoding
+            '-c:a', 'copy',                # copy audio stream without re-encoding
+            '-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)
+            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}")
+            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):
+            os.remove(temp_file)
+        print(f"Error saving prompt to video metadata, ffmpeg may be required: "+str(e))
+        return False
+
+# 20250506 pftq: Modified worker to accept video input, and clean frame count
+@torch.no_grad()
+def worker(input_video, end_frame, end_frame_weight, 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:
+        # Clean GPU
+        if not high_vram:
+            unload_complete_models(
+                text_encoder, text_encoder_2, image_encoder, vae, transformer
+            )
+
+        # Text encoding
+        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Text encoding ...'))))
+
+        if not high_vram:
+            fake_diffusers_current_device(text_encoder, gpu)  # since we only encode one text - that is one model move and one encode, offload is same time consumption since it is also one load and one encode.
+            load_model_as_complete(text_encoder_2, target_device=gpu)
+
+        llama_vec, clip_l_pooler = encode_prompt_conds(prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)
+
+        if cfg == 1:
+            llama_vec_n, clip_l_pooler_n = torch.zeros_like(llama_vec), torch.zeros_like(clip_l_pooler)
+        else:
+            llama_vec_n, clip_l_pooler_n = encode_prompt_conds(n_prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)
+
+        llama_vec, llama_attention_mask = crop_or_pad_yield_mask(llama_vec, length=512)
+        llama_vec_n, llama_attention_mask_n = crop_or_pad_yield_mask(llama_vec_n, length=512)
+
+        # 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, input_video_pixels, end_of_input_video_latent, end_of_input_video_image_np = 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')) 
+
+        # CLIP Vision
+        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'CLIP Vision encoding ...'))))
+
+        if not high_vram:
+            load_model_as_complete(image_encoder, target_device=gpu)
+
+        image_encoder_output = hf_clip_vision_encode(input_image_np, feature_extractor, image_encoder)
+        image_encoder_last_hidden_state = image_encoder_output.last_hidden_state
+        start_embedding = image_encoder_last_hidden_state
+        
+        end_of_input_video_output = hf_clip_vision_encode(end_of_input_video_image_np, feature_extractor, image_encoder)
+        end_of_input_video_last_hidden_state = end_of_input_video_output.last_hidden_state
+        end_of_input_video_embedding = end_of_input_video_last_hidden_state
+
+        # 20250507 pftq: Process end frame if provided
+        end_latent = None
+        end_clip_embedding = None
+        if end_frame is not None:
+            stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'End frame encoding ...'))))
+            end_latent, end_clip_embedding, _ = image_encode(
+                end_frame, target_width=width, target_height=height, vae=vae,
+                image_encoder=image_encoder, feature_extractor=feature_extractor, device=gpu
+            )
+
+        # Dtype
+        llama_vec = llama_vec.to(transformer.dtype)
+        llama_vec_n = llama_vec_n.to(transformer.dtype)
+        clip_l_pooler = clip_l_pooler.to(transformer.dtype)
+        clip_l_pooler_n = clip_l_pooler_n.to(transformer.dtype)
+        image_encoder_last_hidden_state = image_encoder_last_hidden_state.to(transformer.dtype)
+        end_of_input_video_embedding = end_of_input_video_embedding.to(transformer.dtype)
+
+        # 20250509 pftq: Restored original placement of total_latent_sections after video_encode
+        total_latent_sections = (total_second_length * fps) / (latent_window_size * 4)
+        total_latent_sections = int(max(round(total_latent_sections), 1))
+
+        for idx in range(batch):
+            if batch > 1:
+                print(f"Beginning video {idx+1} of {batch} with seed {seed} ")
+            
+            job_id = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")+f"_framepack-videoinput-endframe_{width}-{total_second_length}sec_seed-{seed}_steps-{steps}_distilled-{gs}_cfg-{cfg}"
+            
+            stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Start sampling ...'))))
+    
+            rnd = torch.Generator("cpu").manual_seed(seed)
+    
+            history_latents = video_latents.cpu()
+            history_pixels = None
+            total_generated_latent_frames = 0
+            previous_video = None
+            
+            
+            # 20250509 Generate backwards with end frame for better end frame anchoring
+            if total_latent_sections > 4:
+                latent_paddings = [3] + [2] * (total_latent_sections - 3) + [1, 0]
+            else:
+                latent_paddings = list(reversed(range(total_latent_sections)))
+
+            for section_index, latent_padding in enumerate(latent_paddings):
+                is_start_of_video = latent_padding == 0
+                is_end_of_video = latent_padding == latent_paddings[0]
+                latent_padding_size = latent_padding * latent_window_size
+
+                if stream.input_queue.top() == 'end':
+                    stream.output_queue.push(('end', None))
+                    return
+
+                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):
+                    try:
+                        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}. Generating part {total_latent_sections - section_index} of {total_latent_sections} backward...'
+                        stream.output_queue.push(('progress', (preview, desc, make_progress_bar_html(percentage, hint))))
+                    except ConnectionResetError as e:
+                        print(f"Suppressed ConnectionResetError in callback: {e}")
+                    return
+
+                # 20250509 pftq: Dynamic frame allocation like original num_clean_frames, fix split error
+                available_frames = video_latents.shape[2] if is_start_of_video else history_latents.shape[2]
+                if is_start_of_video:
+                    effective_clean_frames = 1 # avoid jumpcuts from input video
+                else:
+                    effective_clean_frames = max(0, num_clean_frames - 1) if num_clean_frames > 1 else 1
+                clean_latent_pre_frames = effective_clean_frames 
+                num_2x_frames = min(2, max(1, available_frames - clean_latent_pre_frames - 1)) if available_frames > clean_latent_pre_frames + 1 else 1
+                num_4x_frames = min(16, max(1, available_frames - clean_latent_pre_frames - num_2x_frames)) if available_frames > clean_latent_pre_frames + num_2x_frames else 1
+                total_context_frames = num_2x_frames + num_4x_frames
+                total_context_frames = min(total_context_frames, available_frames - clean_latent_pre_frames)
+
+                # 20250511 pftq: Dynamically adjust post_frames based on clean_latents_post
+                post_frames = 1 if is_end_of_video and end_latent is not None else effective_clean_frames  # 20250511 pftq: Single frame for end_latent, otherwise padding causes still image
+                indices = torch.arange(0, clean_latent_pre_frames + latent_padding_size + latent_window_size + post_frames + num_2x_frames + num_4x_frames).unsqueeze(0)
+                clean_latent_indices_pre, blank_indices, latent_indices, clean_latent_indices_post, clean_latent_2x_indices, clean_latent_4x_indices = indices.split(
+                    [clean_latent_pre_frames, latent_padding_size, latent_window_size, post_frames, num_2x_frames, num_4x_frames], dim=1
+                )
+                clean_latent_indices = torch.cat([clean_latent_indices_pre, clean_latent_indices_post], dim=1)
+
+                # 20250509 pftq: Split context frames dynamically for 2x and 4x only
+                context_frames = history_latents[:, :, -(total_context_frames + clean_latent_pre_frames):-clean_latent_pre_frames, :, :] if total_context_frames > 0 else history_latents[:, :, :1, :, :]
+                split_sizes = [num_4x_frames, num_2x_frames]
+                split_sizes = [s for s in split_sizes if s > 0]
+                if split_sizes and context_frames.shape[2] >= sum(split_sizes):
+                    splits = context_frames.split(split_sizes, dim=2)
+                    split_idx = 0
+                    clean_latents_4x = splits[split_idx] if num_4x_frames > 0 else history_latents[:, :, :1, :, :]
+                    split_idx += 1 if num_4x_frames > 0 else 0
+                    clean_latents_2x = splits[split_idx] if num_2x_frames > 0 and split_idx < len(splits) else history_latents[:, :, :1, :, :]
+                else:
+                    clean_latents_4x = clean_latents_2x = history_latents[:, :, :1, :, :]
+
+                clean_latents_pre = video_latents[:, :, -min(effective_clean_frames, video_latents.shape[2]):].to(history_latents)  # smoother motion but jumpcuts if end frame is too different, must change clean_latent_pre_frames to effective_clean_frames also
+                clean_latents_post = history_latents[:, :, :min(effective_clean_frames, history_latents.shape[2]), :, :] # smoother motion, must change post_frames to effective_clean_frames also
+                    
+                if is_end_of_video:
+                    clean_latents_post = torch.zeros_like(end_of_input_video_latent).to(history_latents)
+                
+                # 20250509 pftq: handle end frame if available
+                if end_latent is not None:
+                    #current_end_frame_weight = end_frame_weight * (latent_padding / latent_paddings[0])
+                    #current_end_frame_weight = current_end_frame_weight * 0.5 + 0.5
+                    current_end_frame_weight = end_frame_weight # changing this over time introduces discontinuity
+                    # 20250511 pftq: Removed end frame weight adjustment as it has no effect
+                    image_encoder_last_hidden_state = (1 - current_end_frame_weight) * end_of_input_video_embedding + end_clip_embedding * current_end_frame_weight
+                    image_encoder_last_hidden_state = image_encoder_last_hidden_state.to(transformer.dtype)
+                    
+                    # 20250511 pftq: Use end_latent only
+                    if is_end_of_video:
+                        clean_latents_post = end_latent.to(history_latents)[:, :, :1, :, :]  # Ensure single frame
+                    
+                # 20250511 pftq: Pad clean_latents_pre to match clean_latent_pre_frames if needed
+                if clean_latents_pre.shape[2] < clean_latent_pre_frames:
+                    clean_latents_pre = clean_latents_pre.repeat(1, 1, clean_latent_pre_frames // clean_latents_pre.shape[2], 1, 1)
+                # 20250511 pftq: Pad clean_latents_post to match post_frames if needed
+                if clean_latents_post.shape[2] < post_frames:
+                    clean_latents_post = clean_latents_post.repeat(1, 1, post_frames // clean_latents_post.shape[2], 1, 1)
+                 
+                clean_latents = torch.cat([clean_latents_pre, clean_latents_post], dim=2)
+
+                max_frames = min(latent_window_size * 4 - 3, history_latents.shape[2] * 4)
+                print(f"Generating video {idx+1} of {batch} with seed {seed}, part {total_latent_sections - section_index} of {total_latent_sections} backward")
+                generated_latents = sample_hunyuan(
+                    transformer=transformer,
+                    sampler='unipc',
+                    width=width,
+                    height=height,
+                    frames=max_frames,
+                    real_guidance_scale=cfg,
+                    distilled_guidance_scale=gs,
+                    guidance_rescale=rs,
+                    num_inference_steps=steps,
+                    generator=rnd,
+                    prompt_embeds=llama_vec,
+                    prompt_embeds_mask=llama_attention_mask,
+                    prompt_poolers=clip_l_pooler,
+                    negative_prompt_embeds=llama_vec_n,
+                    negative_prompt_embeds_mask=llama_attention_mask_n,
+                    negative_prompt_poolers=clip_l_pooler_n,
+                    device=gpu,
+                    dtype=torch.bfloat16,
+                    image_embeddings=image_encoder_last_hidden_state,
+                    latent_indices=latent_indices,
+                    clean_latents=clean_latents,
+                    clean_latent_indices=clean_latent_indices,
+                    clean_latents_2x=clean_latents_2x,
+                    clean_latent_2x_indices=clean_latent_2x_indices,
+                    clean_latents_4x=clean_latents_4x,
+                    clean_latent_4x_indices=clean_latent_4x_indices,
+                    callback=callback,
+                )
+
+                if is_start_of_video:
+                    generated_latents = torch.cat([video_latents[:, :, -1:].to(generated_latents), generated_latents], dim=2)
+
+                total_generated_latent_frames += int(generated_latents.shape[2])
+                history_latents = torch.cat([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)
+
+                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 + 1) if is_start_of_video else (latent_window_size * 2)
+                    overlapped_frames = latent_window_size * 4 - 3
+                    current_pixels = vae_decode(real_history_latents[:, :, :section_latent_frames], vae).cpu()
+                    history_pixels = soft_append_bcthw(current_pixels, history_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')
+                save_bcthw_as_mp4(history_pixels, output_filename, fps=fps, crf=mp4_crf)
+                print(f"Latest video saved: {output_filename}")
+                set_mp4_comments_imageio_ffmpeg(output_filename, f"Prompt: {prompt} | Negative Prompt: {n_prompt}")
+                print(f"Prompt saved to mp4 metadata comments: {output_filename}")
+
+                if previous_video is not None and os.path.exists(previous_video):
+                    try:
+                        os.remove(previous_video)
+                        print(f"Previous partial video deleted: {previous_video}")
+                    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))
+
+                if is_start_of_video:
+                    break
+
+            history_pixels = torch.cat([input_video_pixels, history_pixels], dim=2)
+            #overlapped_frames = latent_window_size * 4 - 3
+            #history_pixels = soft_append_bcthw(input_video_pixels, history_pixels, overlapped_frames)
+
+            output_filename = os.path.join(outputs_folder, f'{job_id}_final.mp4')
+            save_bcthw_as_mp4(history_pixels, output_filename, fps=fps, crf=mp4_crf)
+            print(f"Final video with input blend saved: {output_filename}")
+            set_mp4_comments_imageio_ffmpeg(output_filename, f"Prompt: {prompt} | Negative Prompt: {n_prompt}")
+            print(f"Prompt saved to mp4 metadata comments: {output_filename}")
+            stream.output_queue.push(('file', output_filename))
+    
+            if previous_video is not None and os.path.exists(previous_video):
+                try:
+                    os.remove(previous_video)
+                    print(f"Previous partial video deleted: {previous_video}")
+                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
+
+    except:
+        traceback.print_exc()
+
+        if not high_vram:
+            unload_complete_models(
+                text_encoder, text_encoder_2, image_encoder, vae, transformer
+            )
+
+    stream.output_queue.push(('end', None))
+    return
+    
+# 20250506 pftq: Modified process to pass clean frame count, etc
+def get_duration(
+    input_video, end_frame, end_frame_weight, 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):
+    return total_second_length * 60 * 2
+
+@spaces.GPU(duration=get_duration)
+def process(
+            input_video, end_frame, end_frame_weight, 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
+
+    if torch.cuda.device_count() == 0:
+        gr.Warning('Set this space to GPU config to make it work.')
+        return None, None, None, None, None, None
+
+    if randomize_seed:
+        seed = random.randint(0, np.iinfo(np.int32).max)
+
+    # 20250506 pftq: Updated assertion for video input
+    assert input_video is not None, 'No input video!'
+
+    yield None, None, '', '', gr.update(interactive=False), gr.update(interactive=True)
+
+    # 20250507 pftq: Even the H100 needs offloading if the video dimensions are 720p or higher
+    if high_vram and (no_resize or resolution>640):
+        print("Disabling high vram mode due to no resize and/or potentially higher resolution...")
+        high_vram = False
+        vae.enable_slicing()
+        vae.enable_tiling()
+        DynamicSwapInstaller.install_model(transformer, device=gpu)
+        DynamicSwapInstaller.install_model(text_encoder, device=gpu)
+        
+    # 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, end_frame, end_frame_weight, 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
+
+    while True:
+        flag, data = stream.output_queue.next()
+
+        if flag == 'file':
+            output_filename = data
+            yield output_filename, gr.update(), gr.update(), gr.update(), gr.update(interactive=False), gr.update(interactive=True)
+
+        if flag == 'progress':
+            preview, desc, html = data
+            #yield gr.update(), gr.update(visible=True, value=preview), desc, html, gr.update(interactive=False), gr.update(interactive=True)
+            yield output_filename, gr.update(visible=True, value=preview), desc, html, gr.update(interactive=False), gr.update(interactive=True) # 20250506 pftq: Keep refreshing the video in case it got hidden when the tab was in the background
+
+        if flag == 'end':
+            yield output_filename, gr.update(visible=False), desc+' Video complete.', '', gr.update(interactive=True), gr.update(interactive=False)
+            break
+
+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(
+    max_size=10  # 20250507 pftq: Limit queue size
+)
+with block:
+    if torch.cuda.device_count() == 0:
+        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 with Video Input (Video Extension) + End Frame')
+    with gr.Row():
+        with gr.Column():
+        
+            # 20250506 pftq: Changed to Video input from Image
+            with gr.Row():
+                input_video = gr.Video(sources='upload', label="Input Video", height=320)
+                with gr.Column():
+                  # 20250507 pftq: Added end_frame + weight
+                  end_frame = gr.Image(sources='upload', type="numpy", label="End Frame (Optional) - Reduce context frames if very different from input video or if it is jumpcutting/slowing to still image.", height=320)
+                  end_frame_weight = gr.Slider(label="End Frame Weight", minimum=0.0, maximum=1.0, value=1.0, step=0.01, info='Reduce to treat more as a reference image; no effect')
+                
+            prompt = gr.Textbox(label="Prompt", value='')
+
+            with gr.Row():
+                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():
+                    use_teacache = gr.Checkbox(label='Use TeaCache', value=True, info='Faster speed, but often makes hands and fingers slightly worse.')
+                    no_resize = gr.Checkbox(label='Force Original Video Resolution (No Resizing)', value=False, info='Might run out of VRAM (720p requires > 24GB VRAM).')
+
+                    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)
+
+                batch = gr.Slider(label="Batch Size (Number of Videos)", minimum=1, maximum=1000, value=1, step=1, info='Generate multiple videos each with a different seed.')
+
+                resolution = gr.Number(label="Resolution (max width or height)", value=640, precision=0)
+
+                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=10.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, info='Use instead of Distilled for more detail/control + Negative Prompt (make sure Distilled=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)  # Should not change
+
+                n_prompt = gr.Textbox(label="Negative Prompt", value="Missing arm, unrealistic position, blurred, blurry", 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='Expensive. 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 (Adherence to Video)", minimum=2, maximum=10, value=5, step=1, info="Expensive. Retain more video details. Reduce if memory issues or motion too restricted (jumpcut, ignoring prompt, still).")
+
+                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="Expensive. Increase for better quality frames during fast motion. Reduce if running out of memory")
+
+                latent_window_size = gr.Slider(label="Latent Window Size", minimum=9, maximum=49, value=9, step=1, info='Expensive. Generate more frames at a time (larger chunks). Less degradation 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.Column():
+            preview_image = gr.Image(label="Next Latents", height=200, visible=False)
+            result_video = gr.Video(label="Finished Frames", autoplay=True, show_share_button=False, height=512, loop=True)
+            progress_desc = gr.Markdown('', elem_classes='no-generating-animation')
+            progress_bar = gr.HTML('', elem_classes='no-generating-animation')
+
+    # 20250506 pftq: Updated inputs to include num_clean_frames
+    ips = [input_video, end_frame, end_frame_weight, 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])
+    end_button.click(fn=end_process)
+
+block.launch(share=True)

diffusers_helper/bucket_tools.py

@@ -15,6 +15,79 @@ bucket_options = {
         (864, 448),
         (960, 416),
     ],
+    672: [
+        (480, 864),
+        (512, 832),
+        (544, 768),
+        (576, 704),
+        (608, 672),
+        (640, 640),
+        (672, 608),
+        (704, 576),
+        (768, 544),
+        (832, 512),
+        (864, 480),
+    ],
+    704: [
+        (480, 960),
+        (512, 864),
+        (544, 832),
+        (576, 768),
+        (608, 704),
+        (640, 672),
+        (672, 640),
+        (704, 608),
+        (768, 576),
+        (832, 544),
+        (864, 512),
+        (960, 480),
+    ],
+    768: [
+        (512, 960),
+        (544, 864),
+        (576, 832),
+        (608, 768),
+        (640, 704),
+        (672, 672),
+        (704, 640),
+        (768, 608),
+        (832, 576),
+        (864, 544),
+        (960, 512),
+    ],
+    832: [
+        (544, 960),
+        (576, 864),
+        (608, 832),
+        (640, 768),
+        (672, 704),
+        (704, 672),
+        (768, 640),
+        (832, 608),
+        (864, 576),
+        (960, 544),
+    ],
+    864: [
+        (576, 960),
+        (608, 864),
+        (640, 832),
+        (672, 768),
+        (704, 704),
+        (768, 672),
+        (832, 640),
+        (864, 608),
+        (960, 576),
+    ],
+    960: [
+        (608, 960),
+        (640, 864),
+        (672, 832),
+        (704, 768),
+        (768, 704),
+        (832, 672),
+        (864, 640),
+        (960, 608),
+    ],
 }
 
 
@@ -26,5 +99,5 @@ def find_nearest_bucket(h, w, resolution=640):
         if metric <= min_metric:
             min_metric = metric
             best_bucket = (bucket_h, bucket_w)
+    print("The resolution of the generated video will be " + str(best_bucket))
     return best_bucket
-

diffusers_helper/models/hunyuan_video_packed.py

@@ -362,7 +362,7 @@ class HunyuanVideoIndividualTokenRefiner(nn.Module):
             batch_size = attention_mask.shape[0]
             seq_len = attention_mask.shape[1]
             attention_mask = attention_mask.to(hidden_states.device).bool()
-            self_attn_mask_1 = attention_mask.view(batch_size, 1, 1, seq_len).repeat(1, 1, seq_len, 1)
+            self_attn_mask_1 = attention_mask.view(batch_size, 1, 1, seq_len).expand(-1, -1, seq_len, -1)
             self_attn_mask_2 = self_attn_mask_1.transpose(2, 3)
             self_attn_mask = (self_attn_mask_1 & self_attn_mask_2).bool()
             self_attn_mask[:, :, :, 0] = True

img_examples/{1.png → Example1.mp4}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a7d3490cb499fdbf55d64ad2f06e7c7e7a336245ba2cff50ddb2c9b47299cdae
-size 1329228
+oid sha256:a906a1d14d1699f67ca54865c7aa5857e55246f4ec63bbaf3edcf359e73bebd1
+size 240647

requirements.txt

@@ -1,12 +1,12 @@
-accelerate==1.6.0
+accelerate==1.7.0
 diffusers==0.33.1
-transformers==4.46.2
+transformers==4.52.4
 sentencepiece==0.2.0
-pillow==11.1.0
+pillow==11.2.1
 av==12.1.0
 numpy==1.26.2
 scipy==1.12.0
-requests==2.31.0
+requests==2.32.4
 torchsde==0.2.6
 torch>=2.0.0
 torchvision
@@ -15,4 +15,10 @@ einops
 opencv-contrib-python
 safetensors
 huggingface_hub
-spaces
+decord
+imageio_ffmpeg
+sageattention==1.0.6
+xformers==0.0.29.post3
+bitsandbytes==0.46.0
+pillow-heif==0.22.0
+spaces[security]