Make code closer

app.py

@@ -109,6 +109,8 @@ stream = AsyncStream()
 outputs_folder = './outputs/'
 os.makedirs(outputs_folder, exist_ok=True)
 
+input_image_debug_value = input_video_debug_value = prompt_debug_value = total_second_length_debug_value = None
+
 default_local_storage = {
         "generation-mode": "image",
     }
@@ -599,6 +601,285 @@ def worker_video(input_video, prompts, n_prompt, seed, batch, resolution, total_
         total_latent_sections = (total_second_length * fps) / (latent_window_size * 4)
         total_latent_sections = int(max(round(total_latent_sections), 1))
 
+        if enable_preview:
+            def callback(d):
+                preview = d['denoised']
+                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
+
+        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, sum([1, num_4x_frames, num_2x_frames, effective_clean_frames, adjusted_latent_frames])).unsqueeze(0) # 20250507 pftq: latent_window_size to adjusted_latent_frames for edge case for <=1 sec videos
+            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)
+
+            # 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
+            ############################################### code from image
+            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)
+            # 20250506 pftq: Initialize history_pixels to fix UnboundLocalError
+            history_pixels = None
+            previous_video = None
+
+            history_latents = torch.cat([history_latents, start_latent], 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 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)
+
+                indices = torch.arange(0, sum([1, 16, 2, 1, latent_window_size])).unsqueeze(0)
+                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)
+
+                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, clean_latents_1x], dim=2)
+
+                generated_latents = sample_hunyuan(
+                    transformer=transformer,
+                    sampler='unipc',
+                    width=width,
+                    height=height,
+                    frames=latent_window_size * 4 - 3,
+                    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()
+
+                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
+
+    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 worker to accept video input and clean frame count
+@spaces.GPU()
+@torch.no_grad()
+def worker_video_original(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)
+
+        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]
+
+    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)
+
+        prompt_parameters = []
+
+        for prompt_part in prompts:
+            prompt_parameters.append(encode_prompt(prompt_part, n_prompt))
+
+        # 20250506 pftq: Processing input video instead of image
+        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Video processing ...'))))
+
+        # 20250506 pftq: Encode video
+        start_latent, input_image_np, video_latents, fps, height, width = video_encode(input_video, resolution, no_resize, vae, vae_batch_size=vae_batch, device=gpu)[:6]
+        start_latent = start_latent.to(dtype=torch.float32).cpu()
+        video_latents = video_latents.cpu()
+
+        # 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
+
+        # Dtype
+        image_encoder_last_hidden_state = image_encoder_last_hidden_state.to(transformer.dtype)
+
+        total_latent_sections = (total_second_length * fps) / (latent_window_size * 4)
+        total_latent_sections = int(max(round(total_latent_sections), 1))
+
         if enable_preview:
             def callback(d):
                 preview = d['denoised']
@@ -755,15 +1036,15 @@ def worker_video(input_video, prompts, n_prompt, seed, batch, resolution, total_
                     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:
+                    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])
+                    section_latent_frames = latent_window_size * 2
+                    overlapped_frames = min(latent_window_size * 4 - 3, history_pixels.shape[2])
 
-                  history_pixels = soft_append_bcthw(history_pixels, vae_decode(real_history_latents[:, :, -section_latent_frames:], vae).cpu(), overlapped_frames)
+                    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()
@@ -805,6 +1086,10 @@ def worker_video(input_video, prompts, n_prompt, seed, batch, resolution, total_
     return
 
 def get_duration(input_image, image_position, prompt, generation_mode, n_prompt, randomize_seed, seed, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, mp4_crf):
+    global total_second_length_debug_value
+
+    if total_second_length_debug_value is not None:
+        return min(total_second_length_debug_value * 60 * 10, 600)
     return total_second_length * 60 * (0.9 if use_teacache else 1.5) * (1 + ((steps - 25) / 100))
 
 @spaces.GPU(duration=get_duration)
@@ -828,7 +1113,13 @@ def process(input_image,
             mp4_crf=16
            ):
     start = time.time()
-    global stream
+    global stream, input_image_debug_value, prompt_debug_value, total_second_length_debug_value
+
+    if input_image_debug_value is not None or prompt_debug_value is not None or total_second_length_debug_value is not None:
+        input_image = input_image_debug_value
+        prompt = prompt_debug_value
+        total_second_length = total_second_length_debug_value
+        input_image_debug_value = prompt_debug_value = total_second_length_debug_value = None
 
     if torch.cuda.device_count() == 0:
         gr.Warning('Set this space to GPU config to make it work.')
@@ -880,13 +1171,22 @@ def process(input_image,
             break
 
 def get_duration_video(input_video, prompt, n_prompt, randomize_seed, seed, batch, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch):
+    global total_second_length_debug_value
+    if total_second_length_debug_value is not None:
+        return min(total_second_length_debug_value * 60 * 10, 600)
     return total_second_length * 60 * (0.9 if use_teacache else 2.3) * (1 + ((steps - 25) / 100))
 
 # 20250506 pftq: Modified process to pass clean frame count, etc from video_encode
 @spaces.GPU(duration=get_duration_video)
 def process_video(input_video, prompt, n_prompt, randomize_seed, seed, batch, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch):
     start = time.time()
-    global stream, high_vram
+    global stream, high_vram, input_video_debug_value, prompt_debug_value, total_second_length_debug_value
+
+    if input_video_debug_value is not None or prompt_debug_value is not None or total_second_length_debug_value is not None:
+        input_video = input_video_debug_value
+        prompt = prompt_debug_value
+        total_second_length = total_second_length_debug_value
+        input_video_debug_value = prompt_debug_value = total_second_length_debug_value = None
 
     if torch.cuda.device_count() == 0:
         gr.Warning('Set this space to GPU config to make it work.')
@@ -932,7 +1232,6 @@ def process_video(input_video, prompt, n_prompt, randomize_seed, seed, batch, re
 
         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':
@@ -1089,6 +1388,12 @@ with block:
                     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.Accordion("Debug", open=False):
+                input_image_debug = gr.Image(type="numpy", label="Image Debug", height=320)
+                input_video_debug = gr.Video(sources='upload', label="Input Video Debug", height=320)
+                prompt_debug = gr.Textbox(label="Prompt Debug", value='')
+                total_second_length_debug = gr.Slider(label="Additional Video Length to Generate (seconds) Debug", minimum=1, maximum=120, value=1, step=0.1)
+
         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)
@@ -1099,6 +1404,134 @@ with block:
     ips = [input_image, image_position, final_prompt, generation_mode, n_prompt, randomize_seed, seed, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, mp4_crf]
     ips_video = [input_video, final_prompt, n_prompt, randomize_seed, seed, batch, resolution, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, enable_preview, use_teacache, no_resize, mp4_crf, num_clean_frames, vae_batch]
 
+    with gr.Row(elem_id="image_examples", visible=False):
+        gr.Examples(
+        label = "Examples from image",
+            examples = [
+                    [
+                        "./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 and the man listens",
+                        "image", # generation_mode
+                        "Missing arm, unrealistic position, impossible contortion, visible bone, muscle contraction, blurred, blurry", # n_prompt
+                        True, # randomize_seed
+                        42, # seed
+                        672, # resolution
+                        1, # total_second_length
+                        9, # latent_window_size
+                        25, # steps
+                        1.0, # cfg
+                        10.0, # gs
+                        0.0, # rs
+                        6, # gpu_memory_preservation
+                        False, # enable_preview
+                        False, # use_teacache
+                        16 # mp4_crf
+                    ],
+                    [
+                        "./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, unrealistic position, impossible contortion, visible bone, muscle contraction, blurred, blurry", # n_prompt
+                        True, # randomize_seed
+                        42, # seed
+                        672, # resolution
+                        1, # total_second_length
+                        9, # latent_window_size
+                        25, # steps
+                        1.0, # cfg
+                        10.0, # gs
+                        0.0, # rs
+                        6, # gpu_memory_preservation
+                        False, # enable_preview
+                        True, # use_teacache
+                        16 # mp4_crf
+                    ],
+                    [
+                        "./img_examples/Example4.webp", # input_image
+                        100, # image_position
+                        "A building starting to explode, photorealistic, realisitc, 8k, insanely detailed",
+                        "image", # generation_mode
+                        "Missing arm, unrealistic position, impossible contortion, visible bone, muscle contraction, blurred, blurry", # n_prompt
+                        True, # randomize_seed
+                        42, # seed
+                        672, # resolution
+                        1, # total_second_length
+                        9, # latent_window_size
+                        25, # steps
+                        1.0, # cfg
+                        10.0, # gs
+                        0.0, # rs
+                        6, # gpu_memory_preservation
+                        False, # enable_preview
+                        False, # use_teacache
+                        16 # mp4_crf
+                    ],
+                ],
+            run_on_click = True,
+            fn = process,
+	        inputs = ips,
+            outputs = [result_video, preview_image, progress_desc, progress_bar, start_button, end_button],
+            cache_examples = torch.cuda.device_count() > 0,
+        )
+
+    with gr.Row(elem_id="video_examples", visible=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, unrealistic position, impossible contortion, visible bone, muscle contraction, blurred, blurry", # n_prompt
+                        True, # randomize_seed
+                        42, # seed
+                        1, # batch
+                        672, # resolution
+                        1, # total_second_length
+                        9, # latent_window_size
+                        25, # steps
+                        1.0, # cfg
+                        10.0, # gs
+                        0.0, # rs
+                        6, # gpu_memory_preservation
+                        False, # enable_preview
+                        False, # use_teacache
+                        False, # no_resize
+                        16, # mp4_crf
+                        5, # num_clean_frames
+                        default_vae
+                    ],
+                    [
+                        "./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, unrealistic position, impossible contortion, visible bone, muscle contraction, blurred, blurry", # n_prompt
+                        True, # randomize_seed
+                        42, # seed
+                        1, # batch
+                        672, # resolution
+                        1, # total_second_length
+                        9, # latent_window_size
+                        25, # 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],
+            cache_examples = torch.cuda.device_count() > 0,
+        )
+
     gr.Examples(
         label = "Examples from image",
         examples = [
@@ -1271,6 +1704,40 @@ with block:
         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)]
 
+    
+    def handle_field_debug_change(input_image_debug_data, input_video_debug_data, prompt_debug_data, total_second_length_debug_data):
+        print("handle_field_debug_change")
+        global input_image_debug_value, input_video_debug_value, prompt_debug_value, total_second_length_debug_value
+        input_image_debug_value = input_image_debug_data
+        input_video_debug_value = input_video_debug_data
+        prompt_debug_value = prompt_debug_data
+        total_second_length_debug_value = total_second_length_debug_data
+        return []
+
+    input_image_debug.upload(
+        fn=handle_field_debug_change,
+        inputs=[input_image_debug, input_video_debug, prompt_debug, total_second_length_debug],
+        outputs=[]
+    )
+    
+    input_video_debug.upload(
+        fn=handle_field_debug_change,
+        inputs=[input_image_debug, input_video_debug, prompt_debug, total_second_length_debug],
+        outputs=[]
+    )
+    
+    prompt_debug.change(
+        fn=handle_field_debug_change,
+        inputs=[input_image_debug, input_video_debug, prompt_debug, total_second_length_debug],
+        outputs=[]
+    )
+    
+    total_second_length_debug.change(
+        fn=handle_field_debug_change,
+        inputs=[input_image_debug, input_video_debug, prompt_debug, total_second_length_debug],
+        outputs=[]
+    )
+    
     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 = [