Upload 59 files

diffueraser/diffueraser.py

@@ -166,7 +166,38 @@ def resize_frames(frames, size=None):
         
     return frames
 
-def read_mask(validation_mask, fps, n_total_frames, img_size, mask_dilation_iter, frames):
+def _odd_kernel_size(value):
+    value = max(0, int(value))
+    if value <= 0:
+        return 0
+    return value * 2 + 1
+
+
+def refine_mask_array(mask, mask_refine_mode="Keep", mask_refine_iterations=0, mask_feather_px=0, mask_dilation_iter=0):
+    mode = str(mask_refine_mode)
+    refine_iterations = max(0, int(mask_refine_iterations))
+    dilation_iterations = max(0, int(mask_dilation_iter))
+    feather_px = max(0, int(mask_feather_px))
+
+    m = (np.asarray(mask) > 0).astype(np.uint8) * 255
+    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
+    if refine_iterations > 0 and mode == "Erode":
+        m = cv2.erode(m, kernel, iterations=refine_iterations)
+    elif refine_iterations > 0 and mode == "Dilate":
+        m = cv2.dilate(m, kernel, iterations=refine_iterations)
+
+    if dilation_iterations > 0:
+        m = cv2.dilate(m, kernel, iterations=dilation_iterations)
+
+    kernel_size = _odd_kernel_size(feather_px)
+    if kernel_size > 0:
+        m = cv2.GaussianBlur(m, (kernel_size, kernel_size), 0)
+    return m
+
+
+def read_mask(
+        validation_mask, fps, n_total_frames, img_size, mask_dilation_iter, frames,
+        mask_refine_mode="Keep", mask_refine_iterations=0, mask_feather_px=0, request_id=None):
     cap = cv2.VideoCapture(validation_mask)
     if not cap.isOpened():
         print("Error: Could not open mask video.")
@@ -189,15 +220,15 @@ def read_mask(validation_mask, fps, n_total_frames, img_size, mask_dilation_iter
         if mask.size != img_size:
             mask = mask.resize(img_size, Image.NEAREST)
         mask = np.asarray(mask)
-        m = np.array(mask > 0).astype(np.uint8)
-        m = cv2.erode(m,
-                    cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3)),
-                    iterations=1)
-        m = cv2.dilate(m,
-                    cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3)),
-                    iterations=mask_dilation_iter)
-
-        mask = Image.fromarray(m * 255)
+        m = refine_mask_array(
+            mask,
+            mask_refine_mode=mask_refine_mode,
+            mask_refine_iterations=mask_refine_iterations,
+            mask_feather_px=mask_feather_px,
+            mask_dilation_iter=mask_dilation_iter,
+        )
+
+        mask = Image.fromarray(m)
         masks.append(mask)
 
         masked_image = np.array(frames[idx])*(1-(np.array(mask)[:,:,np.newaxis].astype(np.float32)/255))
@@ -207,6 +238,16 @@ def read_mask(validation_mask, fps, n_total_frames, img_size, mask_dilation_iter
         idx += 1
     cap.release()
 
+    log_event(
+        "diffueraser.read_mask",
+        "mask refinement applied",
+        request_id=request_id,
+        mask_refine_mode=mask_refine_mode,
+        mask_refine_iterations=mask_refine_iterations,
+        mask_feather_px=mask_feather_px,
+        mask_dilation_iter=mask_dilation_iter,
+        masks=len(masks),
+    )
     return masks, masked_images
 
 def read_priori(priori, fps, n_total_frames, img_size):
@@ -394,6 +435,7 @@ class DiffuEraser:
 
     def forward(self, validation_image, validation_mask, priori, output_path,
                 max_img_size = 1280, video_length=2, mask_dilation_iter=4,
+                mask_refine_mode="Keep", mask_refine_iterations=0, mask_feather_px=0,
                 nframes=22, seed=None, revision = None, guidance_scale=None, blended=True,
                 prompt="", negative_prompt="", request_id=None, output_fps=None, progress_callback=None):
         validation_prompt = prompt or ""
@@ -429,6 +471,9 @@ class DiffuEraser:
             max_img_size=max_img_size,
             nframes=nframes,
             mask_dilation_iter=mask_dilation_iter,
+            mask_refine_mode=mask_refine_mode,
+            mask_refine_iterations=mask_refine_iterations,
+            mask_feather_px=mask_feather_px,
             guidance_scale=guidance_scale_final,
             seed="random" if seed is None else seed,
             prompt_chars=len(validation_prompt),
@@ -458,7 +503,13 @@ class DiffuEraser:
         _progress(0.04, "DiffuEraser: reading mask")
         ################     read mask    ################ 
         with timed_stage("diffueraser.read_mask", request_id=request_id, input=validation_mask):
-            validation_masks_input, validation_images_input = read_mask(validation_mask, fps, video_len, img_size, mask_dilation_iter, frames)
+            validation_masks_input, validation_images_input = read_mask(
+                validation_mask, fps, video_len, img_size, mask_dilation_iter, frames,
+                mask_refine_mode=mask_refine_mode,
+                mask_refine_iterations=mask_refine_iterations,
+                mask_feather_px=mask_feather_px,
+                request_id=request_id,
+            )
             log_event("diffueraser.read_mask", "loaded masks", request_id=request_id, masks=len(validation_masks_input), masked_images=len(validation_images_input))
 
         _progress(0.07, "DiffuEraser: reading ProPainter priori")

gradio_app.py

@@ -14,12 +14,15 @@ except ImportError:
 import datetime
 import os
 import platform
+import shutil
 import time
 import traceback
 import uuid
 from contextlib import contextmanager
 
+import cv2
 import gradio as gr
+import numpy as np
 import torch
 from moviepy.editor import VideoFileClip
 
@@ -319,8 +322,12 @@ diffueraser_path = "weights/diffuEraser"
 propainter_model_dir = "weights/propainter"
 
 # Default Gradio runtime parameters.
+DEFAULT_PRESET = "Remove object / person"
 DEFAULT_MAX_DURATION = 5
 DEFAULT_MASK_DILATION_ITER = 8
+DEFAULT_MASK_REFINE_MODE = "Keep"
+DEFAULT_MASK_REFINE_ITERATIONS = 0
+DEFAULT_MASK_FEATHER_PX = 0
 DEFAULT_MAX_IMG_SIZE = 960
 DEFAULT_REF_STRIDE = 10
 DEFAULT_NEIGHBOR_LENGTH = 10
@@ -333,6 +340,10 @@ DEFAULT_GUIDANCE_SCALE = -1.0
 DEFAULT_OUTPUT_FRAME_RATE = "Same as processed video"
 DEFAULT_ZERO_GPU_DURATION_MODE = "Auto"
 DEFAULT_ZERO_GPU_DURATION = 180
+DEFAULT_PROMPT = ""
+DEFAULT_NEGATIVE_PROMPT = ""
+DEFAULT_FACE_WATERMARK_MODE = "Off"
+DEFAULT_FACE_CORRECTION_STRENGTH = 0.65
 
 FRAME_RATE_CHOICES = ["Original", "24 fps", "15 fps", "12 fps"]
 FRAME_RATE_MAP = {
@@ -359,6 +370,8 @@ PCM_STEP_CHOICES = [
     "LCM-Like LoRA",
 ]
 SCHEDULER_CHOICES = ["Auto", "TCD", "LCM", "UniPC", "DDIM", "Euler", "DPM++ 2M"]
+MASK_REFINE_MODE_CHOICES = ["Erode", "Keep", "Dilate"]
+FACE_WATERMARK_MODE_CHOICES = ["Off", "Preserve original face detail", "Use ProPainter-prior blend"]
 ZERO_GPU_DURATION_MODE_CHOICES = ["Auto", "Manual"]
 PCM_STEP_COUNT = {
     "2-Step": 2,
@@ -372,30 +385,40 @@ PCM_STEP_COUNT = {
 }
 IS_ZEROGPU_SPACE = is_zerogpu_env()
 PRESETS = {
-    "Fast preview": {
-        "max_duration": 4,
-        "max_img_size": 768,
-        "mask_dilation_iter": 6,
-        "subvideo_length": 40,
-        "ref_stride": 12,
-        "neighbor_length": 8,
-        "ckpt": "2-Step",
-        "frame_rate_limit": "12 fps",
+    "Remove object / person": {
+        "max_duration": 5,
+        "max_img_size": 960,
+        "mask_dilation_iter": 8,
+        "mask_refine_mode": "Keep",
+        "mask_refine_iterations": 0,
+        "mask_feather_px": 0,
+        "subvideo_length": DEFAULT_SUBVIDEO_LENGTH,
+        "ref_stride": DEFAULT_REF_STRIDE,
+        "neighbor_length": DEFAULT_NEIGHBOR_LENGTH,
+        "ckpt": "4-Step",
+        "frame_rate_limit": DEFAULT_FRAME_RATE_LIMIT,
         "output_frame_rate": DEFAULT_OUTPUT_FRAME_RATE,
         "scheduler_name": DEFAULT_SCHEDULER,
         "seed": DEFAULT_SEED,
         "guidance_scale": DEFAULT_GUIDANCE_SCALE,
         "zero_gpu_duration_mode": DEFAULT_ZERO_GPU_DURATION_MODE,
-        "zero_gpu_duration": 90,
+        "zero_gpu_duration": DEFAULT_ZERO_GPU_DURATION,
+        "prompt": "",
+        "negative_prompt": "",
+        "face_watermark_mode": DEFAULT_FACE_WATERMARK_MODE,
+        "face_correction_strength": DEFAULT_FACE_CORRECTION_STRENGTH,
     },
-    "Balanced": {
-        "max_duration": DEFAULT_MAX_DURATION,
-        "max_img_size": DEFAULT_MAX_IMG_SIZE,
-        "mask_dilation_iter": DEFAULT_MASK_DILATION_ITER,
+    "Remove small watermark or logo": {
+        "max_duration": 5,
+        "max_img_size": 960,
+        "mask_dilation_iter": 4,
+        "mask_refine_mode": "Keep",
+        "mask_refine_iterations": 0,
+        "mask_feather_px": 4,
         "subvideo_length": DEFAULT_SUBVIDEO_LENGTH,
         "ref_stride": DEFAULT_REF_STRIDE,
         "neighbor_length": DEFAULT_NEIGHBOR_LENGTH,
-        "ckpt": DEFAULT_CKPT,
+        "ckpt": "4-Step",
         "frame_rate_limit": DEFAULT_FRAME_RATE_LIMIT,
         "output_frame_rate": DEFAULT_OUTPUT_FRAME_RATE,
         "scheduler_name": DEFAULT_SCHEDULER,
@@ -403,11 +426,64 @@ PRESETS = {
         "guidance_scale": DEFAULT_GUIDANCE_SCALE,
         "zero_gpu_duration_mode": DEFAULT_ZERO_GPU_DURATION_MODE,
         "zero_gpu_duration": DEFAULT_ZERO_GPU_DURATION,
+        "prompt": "",
+        "negative_prompt": "",
+        "face_watermark_mode": DEFAULT_FACE_WATERMARK_MODE,
+        "face_correction_strength": DEFAULT_FACE_CORRECTION_STRENGTH,
+    },
+    "Face-area watermark": {
+        "max_duration": 5,
+        "max_img_size": 1152,
+        "mask_dilation_iter": 2,
+        "mask_refine_mode": "Erode",
+        "mask_refine_iterations": 1,
+        "mask_feather_px": 4,
+        "subvideo_length": DEFAULT_SUBVIDEO_LENGTH,
+        "ref_stride": DEFAULT_REF_STRIDE,
+        "neighbor_length": DEFAULT_NEIGHBOR_LENGTH,
+        "ckpt": "8-Step",
+        "frame_rate_limit": "Original",
+        "output_frame_rate": DEFAULT_OUTPUT_FRAME_RATE,
+        "scheduler_name": DEFAULT_SCHEDULER,
+        "seed": DEFAULT_SEED,
+        "guidance_scale": DEFAULT_GUIDANCE_SCALE,
+        "zero_gpu_duration_mode": DEFAULT_ZERO_GPU_DURATION_MODE,
+        "zero_gpu_duration": DEFAULT_ZERO_GPU_DURATION,
+        "prompt": "",
+        "negative_prompt": "distorted face, deformed face, blurry face, warped mouth",
+        "face_watermark_mode": "Preserve original face detail",
+        "face_correction_strength": 0.65,
+    },
+    "Fast preview": {
+        "max_duration": 4,
+        "max_img_size": 768,
+        "mask_dilation_iter": 8,
+        "mask_refine_mode": "Keep",
+        "mask_refine_iterations": 0,
+        "mask_feather_px": 0,
+        "subvideo_length": 40,
+        "ref_stride": 12,
+        "neighbor_length": 8,
+        "ckpt": "2-Step",
+        "frame_rate_limit": "12 fps",
+        "output_frame_rate": DEFAULT_OUTPUT_FRAME_RATE,
+        "scheduler_name": DEFAULT_SCHEDULER,
+        "seed": DEFAULT_SEED,
+        "guidance_scale": DEFAULT_GUIDANCE_SCALE,
+        "zero_gpu_duration_mode": DEFAULT_ZERO_GPU_DURATION_MODE,
+        "zero_gpu_duration": 90,
+        "prompt": "",
+        "negative_prompt": "",
+        "face_watermark_mode": DEFAULT_FACE_WATERMARK_MODE,
+        "face_correction_strength": DEFAULT_FACE_CORRECTION_STRENGTH,
     },
-    "Higher quality": {
+    "High quality object removal": {
         "max_duration": 8,
         "max_img_size": 1152,
         "mask_dilation_iter": 8,
+        "mask_refine_mode": "Keep",
+        "mask_refine_iterations": 0,
+        "mask_feather_px": 0,
         "subvideo_length": 60,
         "ref_stride": 10,
         "neighbor_length": 12,
@@ -419,9 +495,36 @@ PRESETS = {
         "guidance_scale": DEFAULT_GUIDANCE_SCALE,
         "zero_gpu_duration_mode": DEFAULT_ZERO_GPU_DURATION_MODE,
         "zero_gpu_duration": DEFAULT_ZERO_GPU_DURATION,
+        "prompt": "",
+        "negative_prompt": "",
+        "face_watermark_mode": DEFAULT_FACE_WATERMARK_MODE,
+        "face_correction_strength": DEFAULT_FACE_CORRECTION_STRENGTH,
     },
 }
 
+TASK_MODE_SUMMARIES = {
+    "Remove object / person": "**Current mode:** object/person removal · wider mask · balanced quality.",
+    "Remove small watermark or logo": "**Current mode:** small logo/watermark · moderate mask · keeps normal inpainting behavior.",
+    "Face-area watermark": "**Current mode:** face-area watermark · small mask · original-face blend · slower.",
+    "Fast preview": "**Current mode:** fast preview · short clip · low FPS · lower quality.",
+    "High quality object removal": "**Current mode:** high quality object removal · larger image size · slower.",
+    "Custom": "**Current mode:** custom settings · Advanced values are used as-is.",
+}
+
+SITUATION_GUIDE = """
+### Choose a task mode
+
+| Situation | Recommended mode | Notes |
+|---|---|---|
+| Remove a whole person, object, or large unwanted region | **Remove object / person** | Best default. Uses a wider mask so object edges are less likely to remain. |
+| Remove a small logo, subtitle, or watermark that is not on a face | **Remove small watermark or logo** | Uses moderate feathering and less dilation than full object removal. |
+| Remove a small watermark over eyes, mouth, or other facial details | **Face-area watermark** | Preserves more original face detail. It may leave some watermark and is not for full-body removal. |
+| Quickly check that the Space works | **Fast preview** | Lower quality, shorter duration, lower FPS. |
+| Object/person removal with more quality and more runtime | **High quality object removal** | Slower. Useful after the normal object mode works. |
+
+If the mask covers a large area, start with **Remove object / person**. Use **Face-area watermark** only for small masks over facial details.
+"""
+
 # Model setup
 with timed_stage("startup.device"):
     device = get_device()
@@ -476,11 +579,98 @@ def trim_video(
         log_event("video.trimmed", label, request_id=request_id, **meta)
 
 
+def _odd_kernel_size(value):
+    value = max(0, int(value))
+    if value <= 0:
+        return 0
+    # Use a radius-like UI value and convert it to an odd Gaussian kernel size.
+    return value * 2 + 1
+
+
+def refine_mask_array(mask, mask_refine_mode="Keep", mask_refine_iterations=0, mask_feather_px=0, mask_dilation_iter=0):
+    mode = str(mask_refine_mode)
+    refine_iterations = max(0, int(mask_refine_iterations))
+    dilation_iterations = max(0, int(mask_dilation_iter))
+    feather_px = max(0, int(mask_feather_px))
+
+    m = (np.asarray(mask) > 0).astype(np.uint8) * 255
+    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
+    if refine_iterations > 0 and mode == "Erode":
+        m = cv2.erode(m, kernel, iterations=refine_iterations)
+    elif refine_iterations > 0 and mode == "Dilate":
+        m = cv2.dilate(m, kernel, iterations=refine_iterations)
+
+    if dilation_iterations > 0:
+        m = cv2.dilate(m, kernel, iterations=dilation_iterations)
+
+    kernel_size = _odd_kernel_size(feather_px)
+    if kernel_size > 0:
+        m = cv2.GaussianBlur(m, (kernel_size, kernel_size), 0)
+    return m
+
+
+def create_refined_mask_preview(
+    input_path,
+    output_path,
+    mask_refine_mode=DEFAULT_MASK_REFINE_MODE,
+    mask_refine_iterations=DEFAULT_MASK_REFINE_ITERATIONS,
+    mask_feather_px=DEFAULT_MASK_FEATHER_PX,
+    mask_dilation_iter=DEFAULT_MASK_DILATION_ITER,
+    request_id=None,
+):
+    with timed_stage(
+        "mask.preview_refined",
+        request_id=request_id,
+        input=input_path,
+        output=output_path,
+        mask_refine_mode=mask_refine_mode,
+        mask_refine_iterations=mask_refine_iterations,
+        mask_feather_px=mask_feather_px,
+        mask_dilation_iter=mask_dilation_iter,
+    ):
+        cap = cv2.VideoCapture(input_path)
+        if not cap.isOpened():
+            raise ValueError("Could not open mask video for refinement preview.")
+        fps = cap.get(cv2.CAP_PROP_FPS) or 15
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+        writer = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+        frames = 0
+        try:
+            while True:
+                ret, frame = cap.read()
+                if not ret:
+                    break
+                gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+                refined = refine_mask_array(
+                    gray,
+                    mask_refine_mode=mask_refine_mode,
+                    mask_refine_iterations=mask_refine_iterations,
+                    mask_feather_px=mask_feather_px,
+                    mask_dilation_iter=mask_dilation_iter,
+                )
+                writer.write(cv2.cvtColor(refined, cv2.COLOR_GRAY2BGR))
+                frames += 1
+        finally:
+            cap.release()
+            writer.release()
+        meta = video_metadata(output_path)
+        log_event("mask.preview_refined", "created refined mask preview", request_id=request_id, frames=frames, **meta)
+
+
+def task_mode_summary(task_mode):
+    return TASK_MODE_SUMMARIES.get(str(task_mode), TASK_MODE_SUMMARIES["Custom"])
+
+
 def apply_preset(
     preset_name,
     max_duration,
     max_img_size,
     mask_dilation_iter,
+    mask_refine_mode,
+    mask_refine_iterations,
+    mask_feather_px,
     subvideo_length,
     ref_stride,
     neighbor_length,
@@ -492,14 +682,20 @@ def apply_preset(
     guidance_scale,
     zero_gpu_duration_mode,
     zero_gpu_duration,
+    face_watermark_mode,
+    face_correction_strength,
     prompt,
     negative_prompt,
 ):
     if preset_name == "Custom":
         return (
+            task_mode_summary(preset_name),
             max_duration,
             max_img_size,
             mask_dilation_iter,
+            mask_refine_mode,
+            mask_refine_iterations,
+            mask_feather_px,
             subvideo_length,
             ref_stride,
             neighbor_length,
@@ -511,15 +707,21 @@ def apply_preset(
             guidance_scale,
             zero_gpu_duration_mode,
             zero_gpu_duration,
+            face_watermark_mode,
+            face_correction_strength,
             prompt,
             negative_prompt,
         )
 
     preset = PRESETS[preset_name]
     return (
+        task_mode_summary(preset_name),
         preset["max_duration"],
         preset["max_img_size"],
         preset["mask_dilation_iter"],
+        preset["mask_refine_mode"],
+        preset["mask_refine_iterations"],
+        preset["mask_feather_px"],
         preset["subvideo_length"],
         preset["ref_stride"],
         preset["neighbor_length"],
@@ -531,13 +733,72 @@ def apply_preset(
         preset["guidance_scale"],
         preset["zero_gpu_duration_mode"],
         preset["zero_gpu_duration"],
-        prompt,
-        negative_prompt,
+        preset.get("face_watermark_mode", DEFAULT_FACE_WATERMARK_MODE),
+        preset.get("face_correction_strength", DEFAULT_FACE_CORRECTION_STRENGTH),
+        preset.get("prompt", prompt),
+        preset.get("negative_prompt", negative_prompt),
     )
 
 
+def inspect_mask_for_warning(mask_path, face_watermark_mode, mask_refine_mode, request_id=None):
+    face_like_mode = str(face_watermark_mode) != "Off" or str(mask_refine_mode) == "Erode"
+    if not face_like_mode:
+        return
+    try:
+        cap = cv2.VideoCapture(mask_path)
+        if not cap.isOpened():
+            return
+        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0)
+        sample_stride = max(1, frame_count // 10) if frame_count else 1
+        ratios = []
+        bbox_ratios = []
+        index = 0
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            if index % sample_stride == 0:
+                gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+                mask = gray > 24
+                ratio = float(mask.mean())
+                ratios.append(ratio)
+                coords = cv2.findNonZero(mask.astype(np.uint8))
+                if coords is not None:
+                    x, y, w, h = cv2.boundingRect(coords)
+                    bbox_ratios.append((w * h) / float(mask.shape[0] * mask.shape[1]))
+            index += 1
+        cap.release()
+        if not ratios:
+            return
+        avg_ratio = sum(ratios) / len(ratios)
+        max_bbox_ratio = max(bbox_ratios) if bbox_ratios else 0.0
+        log_event(
+            "mask.warning_check",
+            "computed mask area",
+            request_id=request_id,
+            avg_mask_ratio=f"{avg_ratio:.3f}",
+            max_bbox_ratio=f"{max_bbox_ratio:.3f}",
+            samples=len(ratios),
+            face_watermark_mode=face_watermark_mode,
+            mask_refine_mode=mask_refine_mode,
+        )
+        if avg_ratio > 0.10 or max_bbox_ratio > 0.22:
+            gr.Warning(
+                "Face-area watermark settings are intended for small face-detail masks. "
+                "This mask looks fairly large, so Remove object / person may work better."
+            )
+            log_event(
+                "mask.warning_check",
+                "warning emitted",
+                request_id=request_id,
+                avg_mask_ratio=f"{avg_ratio:.3f}",
+                max_bbox_ratio=f"{max_bbox_ratio:.3f}",
+            )
+    except Exception as exc:
+        log_event("mask.warning_check", "failed", request_id=request_id, error_type=type(exc).__name__, error=str(exc))
+
 def clear_inputs():
-    return None, None, None, None, None, None
+    return None, None, None, None, None, None, None, None
 
 
 def make_ui_progress(progress, request_id=None):
@@ -577,6 +838,110 @@ def make_stage_progress(progress_update, start, end):
 
 
 
+def blend_video_with_mask(
+    generated_path,
+    base_path,
+    mask_path,
+    output_path,
+    correction_strength=0.65,
+    request_id=None,
+    label="face_watermark_blend",
+):
+    correction_strength = max(0.0, min(1.0, float(correction_strength)))
+    with timed_stage(
+        "postprocess.face_watermark_blend",
+        request_id=request_id,
+        generated=generated_path,
+        base=base_path,
+        mask=mask_path,
+        output=output_path,
+        correction_strength=f"{correction_strength:.2f}",
+        label=label,
+    ):
+        gen_cap = cv2.VideoCapture(generated_path)
+        base_cap = cv2.VideoCapture(base_path)
+        mask_cap = cv2.VideoCapture(mask_path)
+        if not gen_cap.isOpened() or not base_cap.isOpened() or not mask_cap.isOpened():
+            raise ValueError("Could not open one or more videos for face watermark blending.")
+
+        fps = gen_cap.get(cv2.CAP_PROP_FPS) or 15
+        width = int(gen_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(gen_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+        writer = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+        frames = 0
+        try:
+            while True:
+                ret_gen, gen = gen_cap.read()
+                ret_base, base = base_cap.read()
+                ret_mask, mask_frame = mask_cap.read()
+                if not ret_gen:
+                    break
+                if not ret_base:
+                    base = gen
+                if not ret_mask:
+                    mask_frame = np.zeros_like(gen)
+
+                if base.shape[:2] != gen.shape[:2]:
+                    base = cv2.resize(base, (width, height), interpolation=cv2.INTER_LINEAR)
+                if mask_frame.shape[:2] != gen.shape[:2]:
+                    mask_frame = cv2.resize(mask_frame, (width, height), interpolation=cv2.INTER_LINEAR)
+
+                gray = cv2.cvtColor(mask_frame, cv2.COLOR_BGR2GRAY).astype(np.float32) / 255.0
+                # The mask controls where to preserve base details. Outside the mask, keep DiffuEraser's output.
+                preserve_alpha = gray * (1.0 - correction_strength)
+                preserve_alpha = preserve_alpha[:, :, None]
+                blended = gen.astype(np.float32) * (1.0 - preserve_alpha) + base.astype(np.float32) * preserve_alpha
+                writer.write(np.clip(blended, 0, 255).astype(np.uint8))
+                frames += 1
+        finally:
+            gen_cap.release()
+            base_cap.release()
+            mask_cap.release()
+            writer.release()
+
+        meta = video_metadata(output_path)
+        log_event("postprocess.face_watermark_blend", "created blended video", request_id=request_id, frames=frames, **meta)
+
+
+def finalize_output_video(
+    raw_output_path,
+    trimmed_video_path,
+    priori_path,
+    refined_mask_path,
+    output_path,
+    face_watermark_mode=DEFAULT_FACE_WATERMARK_MODE,
+    face_correction_strength=DEFAULT_FACE_CORRECTION_STRENGTH,
+    request_id=None,
+):
+    mode = str(face_watermark_mode)
+    if mode == "Preserve original face detail":
+        blend_video_with_mask(
+            raw_output_path,
+            trimmed_video_path,
+            refined_mask_path,
+            output_path,
+            correction_strength=face_correction_strength,
+            request_id=request_id,
+            label=mode,
+        )
+    elif mode == "Use ProPainter-prior blend":
+        blend_video_with_mask(
+            raw_output_path,
+            priori_path,
+            refined_mask_path,
+            output_path,
+            correction_strength=face_correction_strength,
+            request_id=request_id,
+            label=mode,
+        )
+    else:
+        with timed_stage("postprocess.finalize_output", request_id=request_id, mode=mode, raw_output=raw_output_path, output=output_path):
+            shutil.copyfile(raw_output_path, output_path)
+            meta = video_metadata(output_path)
+            log_event("postprocess.finalize_output", "copied raw DiffuEraser output", request_id=request_id, **meta)
+
+
 def _clip_int(value, minimum=30, maximum=300):
     return max(minimum, min(maximum, int(round(value))))
 
@@ -609,6 +974,7 @@ def estimate_zero_gpu_duration(
     output_frame_rate=DEFAULT_OUTPUT_FRAME_RATE,
     scheduler_name=DEFAULT_SCHEDULER,
     guidance_scale=DEFAULT_GUIDANCE_SCALE,
+    face_watermark_mode=DEFAULT_FACE_WATERMARK_MODE,
 ):
     max_duration = max(1, int(max_duration))
     max_img_size = max(256, int(max_img_size))
@@ -634,9 +1000,10 @@ def estimate_zero_gpu_duration(
     lora_cost = 4.0
     scheduler_cost = 2.0 if scheduler_name != "Auto" else 0.0
     guidance_cost = 4.0 if guidance_scale > 1.0 else 0.0
+    postprocess_cost = 0.0 if str(face_watermark_mode) == "Off" else max(1.0, 0.015 * estimated_frames)
     margin = 5.0
 
-    estimate = base_cost + trim_cost + propainter_cost + lora_cost + scheduler_cost + guidance_cost + frame_cost + margin
+    estimate = base_cost + trim_cost + propainter_cost + lora_cost + scheduler_cost + guidance_cost + frame_cost + postprocess_cost + margin
     duration = _clip_int(estimate)
     return duration, {
         "fps": f"{fps:.2f}",
@@ -646,6 +1013,7 @@ def estimate_zero_gpu_duration(
         "step_factor": f"{step_factor:.2f}",
         "frame_cost_sec": f"{frame_cost:.1f}",
         "propainter_cost_sec": f"{propainter_cost:.1f}",
+        "postprocess_cost_sec": f"{postprocess_cost:.1f}",
         "raw_estimate_sec": f"{estimate:.1f}",
         "margin_sec": f"{margin:.1f}",
         "duration_floor_sec": 30,
@@ -663,6 +1031,7 @@ def resolve_zero_gpu_duration(
     output_frame_rate=DEFAULT_OUTPUT_FRAME_RATE,
     scheduler_name=DEFAULT_SCHEDULER,
     guidance_scale=DEFAULT_GUIDANCE_SCALE,
+    face_watermark_mode=DEFAULT_FACE_WATERMARK_MODE,
     zero_gpu_duration_mode=DEFAULT_ZERO_GPU_DURATION_MODE,
     zero_gpu_duration=DEFAULT_ZERO_GPU_DURATION,
 ):
@@ -676,6 +1045,7 @@ def resolve_zero_gpu_duration(
         frame_rate_limit=frame_rate_limit,
         scheduler_name=scheduler_name,
         guidance_scale=guidance_scale,
+        face_watermark_mode=face_watermark_mode,
     )
     mode = str(zero_gpu_duration_mode)
     if mode == "Manual":
@@ -701,6 +1071,9 @@ def get_duration(
     input_mask,
     max_duration=DEFAULT_MAX_DURATION,
     mask_dilation_iter=DEFAULT_MASK_DILATION_ITER,
+    mask_refine_mode=DEFAULT_MASK_REFINE_MODE,
+    mask_refine_iterations=DEFAULT_MASK_REFINE_ITERATIONS,
+    mask_feather_px=DEFAULT_MASK_FEATHER_PX,
     max_img_size=DEFAULT_MAX_IMG_SIZE,
     ref_stride=DEFAULT_REF_STRIDE,
     neighbor_length=DEFAULT_NEIGHBOR_LENGTH,
@@ -713,6 +1086,8 @@ def get_duration(
     guidance_scale=DEFAULT_GUIDANCE_SCALE,
     zero_gpu_duration_mode=DEFAULT_ZERO_GPU_DURATION_MODE,
     zero_gpu_duration=DEFAULT_ZERO_GPU_DURATION,
+    face_watermark_mode=DEFAULT_FACE_WATERMARK_MODE,
+    face_correction_strength=DEFAULT_FACE_CORRECTION_STRENGTH,
     prompt="",
     negative_prompt="",
     *extra_args,
@@ -727,6 +1102,7 @@ def get_duration(
         frame_rate_limit=frame_rate_limit,
         scheduler_name=scheduler_name,
         guidance_scale=guidance_scale,
+        face_watermark_mode=face_watermark_mode,
         zero_gpu_duration_mode=zero_gpu_duration_mode,
         zero_gpu_duration=zero_gpu_duration,
     )
@@ -742,6 +1118,9 @@ def infer(
     input_mask,
     max_duration=DEFAULT_MAX_DURATION,
     mask_dilation_iter=DEFAULT_MASK_DILATION_ITER,
+    mask_refine_mode=DEFAULT_MASK_REFINE_MODE,
+    mask_refine_iterations=DEFAULT_MASK_REFINE_ITERATIONS,
+    mask_feather_px=DEFAULT_MASK_FEATHER_PX,
     max_img_size=DEFAULT_MAX_IMG_SIZE,
     ref_stride=DEFAULT_REF_STRIDE,
     neighbor_length=DEFAULT_NEIGHBOR_LENGTH,
@@ -754,6 +1133,8 @@ def infer(
     guidance_scale=DEFAULT_GUIDANCE_SCALE,
     zero_gpu_duration_mode=DEFAULT_ZERO_GPU_DURATION_MODE,
     zero_gpu_duration=DEFAULT_ZERO_GPU_DURATION,
+    face_watermark_mode=DEFAULT_FACE_WATERMARK_MODE,
+    face_correction_strength=DEFAULT_FACE_CORRECTION_STRENGTH,
     prompt="",
     negative_prompt="",
     progress=gr.Progress(track_tqdm=True),
@@ -778,6 +1159,9 @@ def infer(
         # Setup paths and parameters
         max_duration = int(max_duration)
         mask_dilation_iter = int(mask_dilation_iter)
+        mask_refine_mode = str(mask_refine_mode)
+        mask_refine_iterations = int(mask_refine_iterations)
+        mask_feather_px = int(mask_feather_px)
         max_img_size = int(max_img_size)
         ref_stride = int(ref_stride)
         neighbor_length = int(neighbor_length)
@@ -792,6 +1176,8 @@ def infer(
         guidance_scale = None if guidance_scale_value < 0 else guidance_scale_value
         zero_gpu_duration_mode = str(zero_gpu_duration_mode)
         zero_gpu_duration = int(zero_gpu_duration)
+        face_watermark_mode = str(face_watermark_mode)
+        face_correction_strength = float(face_correction_strength)
         prompt = str(prompt or "")
         negative_prompt = str(negative_prompt or "")
 
@@ -804,6 +1190,7 @@ def infer(
             frame_rate_limit=frame_rate_limit,
             scheduler_name=scheduler_name,
             guidance_scale=guidance_scale_value,
+            face_watermark_mode=face_watermark_mode,
             zero_gpu_duration_mode=zero_gpu_duration_mode,
             zero_gpu_duration=zero_gpu_duration,
         )
@@ -814,6 +1201,9 @@ def infer(
             request_id=request_id,
             max_duration=max_duration,
             mask_dilation_iter=mask_dilation_iter,
+            mask_refine_mode=mask_refine_mode,
+            mask_refine_iterations=mask_refine_iterations,
+            mask_feather_px=mask_feather_px,
             max_img_size=max_img_size,
             ref_stride=ref_stride,
             neighbor_length=neighbor_length,
@@ -829,6 +1219,8 @@ def infer(
             zero_gpu_duration_manual_slider=zero_gpu_duration_details["manual_slider_sec"],
             zero_gpu_duration_auto_estimate=zero_gpu_duration_details["auto_estimate_sec"],
             zero_gpu_duration_effective=zero_gpu_effective_duration,
+            face_watermark_mode=face_watermark_mode,
+            face_correction_strength=f"{face_correction_strength:.2f}",
             prompt_chars=len(prompt),
             negative_prompt_chars=len(negative_prompt),
         )
@@ -836,7 +1228,9 @@ def infer(
         # Timestamp for unique filenames
         trimmed_video_path = os.path.join(save_path, f"trimmed_video_{timestamp}.mp4")
         trimmed_mask_path = os.path.join(save_path, f"trimmed_mask_{timestamp}.mp4")
+        refined_mask_path = os.path.join(save_path, f"refined_mask_{timestamp}.mp4")
         priori_path = os.path.join(save_path, f"priori_{timestamp}.mp4")
+        raw_output_path = os.path.join(save_path, f"diffueraser_raw_{timestamp}.mp4")
         output_path = os.path.join(save_path, f"diffueraser_result_{timestamp}.mp4")
         log_event(
             "request.paths",
@@ -844,7 +1238,9 @@ def infer(
             request_id=request_id,
             trimmed_video=trimmed_video_path,
             trimmed_mask=trimmed_mask_path,
+            refined_mask=refined_mask_path,
             priori=priori_path,
+            raw_output=raw_output_path,
             output=output_path,
         )
 
@@ -866,6 +1262,21 @@ def infer(
             request_id=request_id,
             label="input_mask",
         )
+        create_refined_mask_preview(
+            trimmed_mask_path,
+            refined_mask_path,
+            mask_refine_mode=mask_refine_mode,
+            mask_refine_iterations=mask_refine_iterations,
+            mask_feather_px=mask_feather_px,
+            mask_dilation_iter=mask_dilation_iter,
+            request_id=request_id,
+        )
+        inspect_mask_for_warning(
+            refined_mask_path,
+            face_watermark_mode=face_watermark_mode,
+            mask_refine_mode=mask_refine_mode,
+            request_id=request_id,
+        )
 
         # Dynamically compute video_length in frames from the trimmed video.
         with timed_stage("video.inspect_trimmed", request_id=request_id):
@@ -896,6 +1307,9 @@ def infer(
             neighbor_length=neighbor_length,
             subvideo_length=subvideo_length,
             mask_dilation=mask_dilation_iter,
+            mask_refine_mode=mask_refine_mode,
+            mask_refine_iterations=mask_refine_iterations,
+            mask_feather_px=mask_feather_px,
         ):
             propainter.forward(trimmed_video_path, trimmed_mask_path, priori_path,
                                video_length=video_length, ref_stride=ref_stride,
@@ -920,15 +1334,30 @@ def infer(
             guidance_scale=guidance_scale,
             seed="random" if seed is None else seed,
         ):
-            video_inpainting_sd.forward(trimmed_video_path, trimmed_mask_path, priori_path, output_path,
+            video_inpainting_sd.forward(trimmed_video_path, trimmed_mask_path, priori_path, raw_output_path,
                                         max_img_size=max_img_size, video_length=video_length,
                                         mask_dilation_iter=mask_dilation_iter,
+                                        mask_refine_mode=mask_refine_mode,
+                                        mask_refine_iterations=mask_refine_iterations,
+                                        mask_feather_px=mask_feather_px,
                                         seed=seed, guidance_scale=guidance_scale,
                                         prompt=prompt, negative_prompt=negative_prompt,
                                         request_id=request_id, output_fps=output_fps,
                                         progress_callback=make_stage_progress(progress_update, 0.40, 0.90))
         log_cuda_memory("after_diffueraser", request_id=request_id)
 
+        progress_update(0.90, desc="Applying final blend")
+        finalize_output_video(
+            raw_output_path,
+            trimmed_video_path,
+            priori_path,
+            refined_mask_path,
+            output_path,
+            face_watermark_mode=face_watermark_mode,
+            face_correction_strength=face_correction_strength,
+            request_id=request_id,
+        )
+
         progress_update(0.92, desc="Finalizing outputs")
         with timed_stage("video.inspect_output", request_id=request_id):
             output_meta = video_metadata(output_path)
@@ -944,12 +1373,14 @@ def infer(
             request_id=request_id,
             total_elapsed_sec=f"{total_elapsed:.2f}",
             output=output_path,
+            raw_output=raw_output_path,
             trimmed_video=trimmed_video_path,
+            refined_mask=refined_mask_path,
             priori=priori_path,
             debug_log=debug_log_path,
         )
         progress_update(1.0, desc="Done")
-        return output_path, trimmed_video_path, priori_path, debug_log_path
+        return output_path, trimmed_video_path, refined_mask_path, priori_path, raw_output_path, debug_log_path
 
     except Exception as exc:
         total_elapsed = time.perf_counter() - total_start
@@ -985,29 +1416,23 @@ with gr.Blocks() as demo:
                 input_video = gr.Video(label="Input Video (MP4 ONLY)")
                 input_mask = gr.Video(label="Input Mask Video (MP4 ONLY)")
                 with gr.Accordion("Basic settings", open=True):
-                    gr.Markdown("For a quick ZeroGPU check, keep the default values or use Fast preview.")
+                    gr.Markdown("Choose a **Task mode** first. Most users only need this and **Max clip duration**.")
                     preset = gr.Dropdown(
-                        label="Preset",
-                        choices=["Fast preview", "Balanced", "Higher quality", "Custom"],
-                        value="Balanced",
-                    )
-                    with gr.Row():
-                        ckpt = gr.Dropdown(
-                            label="PCM checkpoint",
-                            choices=PCM_STEP_CHOICES,
-                            value=DEFAULT_CKPT,
-                        )
-                        frame_rate_limit = gr.Dropdown(
-                            label="Frame rate limit",
-                            choices=FRAME_RATE_CHOICES,
-                            value=DEFAULT_FRAME_RATE_LIMIT,
-                        )
-                    output_frame_rate = gr.Dropdown(
-                        label="Output frame rate",
-                        choices=OUTPUT_FRAME_RATE_CHOICES,
-                        value=DEFAULT_OUTPUT_FRAME_RATE,
-                        info="Can reduce the output video FPS without changing the inference frame rate.",
+                        label="Task mode",
+                        choices=[
+                            "Remove object / person",
+                            "Remove small watermark or logo",
+                            "Face-area watermark",
+                            "Fast preview",
+                            "High quality object removal",
+                            "Custom",
+                        ],
+                        value=DEFAULT_PRESET,
+                        info="Start with the mode that matches what you want to remove.",
                     )
+                    settings_summary = gr.Markdown(task_mode_summary(DEFAULT_PRESET))
+                    with gr.Accordion("Which mode should I choose?", open=False):
+                        gr.Markdown(SITUATION_GUIDE)
                     with gr.Row():
                         max_duration = gr.Slider(
                             label="Max clip duration (seconds)",
@@ -1016,91 +1441,159 @@ with gr.Blocks() as demo:
                             value=DEFAULT_MAX_DURATION,
                             step=1,
                         )
-                        max_img_size = gr.Slider(
-                            label="Maximum image size",
-                            minimum=512,
-                            maximum=1280,
-                            value=DEFAULT_MAX_IMG_SIZE,
-                            step=64,
+                        frame_rate_limit = gr.Dropdown(
+                            label="Frame rate limit",
+                            choices=FRAME_RATE_CHOICES,
+                            value=DEFAULT_FRAME_RATE_LIMIT,
+                            info="Use Original for quality; lower FPS can speed up previews.",
                         )
-                    mask_dilation_iter = gr.Slider(
-                        label="Mask dilation iterations",
-                        minimum=0,
-                        maximum=20,
-                        value=DEFAULT_MASK_DILATION_ITER,
-                        step=1,
-                    )
 
                 with gr.Accordion("Advanced settings", open=False):
-                    gr.Markdown("Optional controls. Auto scheduler keeps the default PCM behavior. Negative prompt is most useful when guidance scale is above 1.")
-                    prompt = gr.Textbox(
-                        label="Prompt",
-                        value="",
-                        lines=2,
-                        placeholder="Optional. Leave blank for the original DiffuEraser behavior.",
-                    )
-                    negative_prompt = gr.Textbox(
-                        label="Negative prompt",
-                        value="",
-                        lines=2,
-                        placeholder="Optional. Mainly affects results when guidance scale is above 1.",
-                    )
-                    with gr.Row():
-                        scheduler_name = gr.Dropdown(
-                            label="Scheduler",
-                            choices=SCHEDULER_CHOICES,
-                            value=DEFAULT_SCHEDULER,
-                        )
+                    gr.Markdown("Optional controls. Keep the task mode defaults unless you are tuning a difficult case.")
+
+                    with gr.Accordion("Quality and speed", open=False):
+                        with gr.Row():
+                            ckpt = gr.Dropdown(
+                                label="PCM checkpoint",
+                                choices=PCM_STEP_CHOICES,
+                                value=DEFAULT_CKPT,
+                                info="More steps can improve quality but take longer.",
+                            )
+                            scheduler_name = gr.Dropdown(
+                                label="Scheduler",
+                                choices=SCHEDULER_CHOICES,
+                                value=DEFAULT_SCHEDULER,
+                                info="Auto keeps the default PCM scheduler behavior.",
+                            )
+                        with gr.Row():
+                            max_img_size = gr.Slider(
+                                label="Maximum image size",
+                                minimum=512,
+                                maximum=1280,
+                                value=DEFAULT_MAX_IMG_SIZE,
+                                step=64,
+                                info="Higher values preserve detail but are slower.",
+                            )
+                            output_frame_rate = gr.Dropdown(
+                                label="Output frame rate",
+                                choices=OUTPUT_FRAME_RATE_CHOICES,
+                                value=DEFAULT_OUTPUT_FRAME_RATE,
+                                info="Can reduce the output video FPS without changing the inference frame rate.",
+                            )
                         seed = gr.Number(
                             label="Seed (-1 for random)",
                             value=DEFAULT_SEED,
                             precision=0,
                         )
-                    guidance_scale = gr.Slider(
-                        label="Guidance scale (-1 uses checkpoint default)",
-                        minimum=-1,
-                        maximum=12,
-                        value=DEFAULT_GUIDANCE_SCALE,
-                        step=0.5,
-                        info="Use -1 to keep each PCM checkpoint's default guidance scale.",
-                    )
-                    with gr.Row(visible=IS_ZEROGPU_SPACE):
-                        zero_gpu_duration_mode = gr.Dropdown(
-                            label="ZeroGPU duration mode",
-                            choices=ZERO_GPU_DURATION_MODE_CHOICES,
-                            value=DEFAULT_ZERO_GPU_DURATION_MODE,
-                            info="Auto estimates the reservation from the current settings. Normal GPU Spaces ignore this setting.",
+
+                    with gr.Accordion("Mask behavior", open=False):
+                        gr.Markdown("Use **Keep/Dilate** for full objects. Use **Erode** only for small face-area masks where preserving facial detail matters.")
+                        mask_dilation_iter = gr.Slider(
+                            label="Mask dilation iterations",
+                            minimum=0,
+                            maximum=20,
+                            value=DEFAULT_MASK_DILATION_ITER,
+                            step=1,
+                            info="Higher values cover object edges better. Lower values preserve more face detail.",
                         )
-                        zero_gpu_duration = gr.Slider(
-                            label="Manual ZeroGPU reserved duration (seconds)",
-                            minimum=30,
-                            maximum=300,
-                            value=DEFAULT_ZERO_GPU_DURATION,
-                            step=30,
-                            info="Used only when ZeroGPU duration mode is Manual.",
+                        with gr.Row():
+                            mask_refine_mode = gr.Dropdown(
+                                label="Mask refine mode",
+                                choices=MASK_REFINE_MODE_CHOICES,
+                                value=DEFAULT_MASK_REFINE_MODE,
+                                info="Keep is safest. Erode shrinks masks. Dilate expands masks.",
+                            )
+                            mask_refine_iterations = gr.Slider(
+                                label="Mask refine iterations",
+                                minimum=0,
+                                maximum=4,
+                                value=DEFAULT_MASK_REFINE_ITERATIONS,
+                                step=1,
+                            )
+                        mask_feather_px = gr.Slider(
+                            label="Mask feather (px)",
+                            minimum=0,
+                            maximum=16,
+                            value=DEFAULT_MASK_FEATHER_PX,
+                            step=1,
+                            info="Softens mask edges for DiffuEraser. Use 0 for the original hard mask behavior.",
                         )
-                    with gr.Row():
-                        subvideo_length = gr.Slider(
-                            label="ProPainter subvideo length",
-                            minimum=10,
-                            maximum=100,
-                            value=DEFAULT_SUBVIDEO_LENGTH,
-                            step=5,
+
+                    with gr.Accordion("Face watermark tuning", open=False):
+                        gr.Markdown("Only for small masks over facial details. This mode trades complete removal for preserving more face detail.")
+                        face_watermark_mode = gr.Dropdown(
+                            label="Face watermark mode",
+                            choices=FACE_WATERMARK_MODE_CHOICES,
+                            value=DEFAULT_FACE_WATERMARK_MODE,
+                            info="Off keeps the normal result. Original blend preserves more original face detail. ProPainter blend can reduce DiffuEraser hallucination.",
                         )
-                        ref_stride = gr.Slider(
-                            label="ProPainter reference stride",
-                            minimum=1,
-                            maximum=20,
-                            value=DEFAULT_REF_STRIDE,
-                            step=1,
+                        face_correction_strength = gr.Slider(
+                            label="Face watermark correction strength",
+                            minimum=0.0,
+                            maximum=1.0,
+                            value=DEFAULT_FACE_CORRECTION_STRENGTH,
+                            step=0.05,
+                            info="Higher removes more of the masked mark. Lower preserves more original/prior face detail.",
+                        )
+                        prompt = gr.Textbox(
+                            label="Prompt",
+                            value=DEFAULT_PROMPT,
+                            lines=2,
+                            placeholder="Optional. Leave blank for the original DiffuEraser behavior.",
+                        )
+                        negative_prompt = gr.Textbox(
+                            label="Negative prompt",
+                            value=DEFAULT_NEGATIVE_PROMPT,
+                            lines=2,
+                            placeholder="Optional. Mainly affects results when guidance scale is above 1.",
+                        )
+                        guidance_scale = gr.Slider(
+                            label="Guidance scale (-1 uses checkpoint default)",
+                            minimum=-1,
+                            maximum=12,
+                            value=DEFAULT_GUIDANCE_SCALE,
+                            step=0.5,
+                            info="Use -1 to keep each PCM checkpoint's default guidance scale.",
+                        )
+
+                    with gr.Accordion("ProPainter and runtime", open=False):
+                        with gr.Row(visible=IS_ZEROGPU_SPACE):
+                            zero_gpu_duration_mode = gr.Dropdown(
+                                label="ZeroGPU duration mode",
+                                choices=ZERO_GPU_DURATION_MODE_CHOICES,
+                                value=DEFAULT_ZERO_GPU_DURATION_MODE,
+                                info="Auto estimates the reservation from the current settings. Normal GPU Spaces ignore this setting.",
+                            )
+                            zero_gpu_duration = gr.Slider(
+                                label="Manual ZeroGPU reserved duration (seconds)",
+                                minimum=30,
+                                maximum=300,
+                                value=DEFAULT_ZERO_GPU_DURATION,
+                                step=30,
+                                info="Used only when ZeroGPU duration mode is Manual.",
+                            )
+                        with gr.Row():
+                            subvideo_length = gr.Slider(
+                                label="ProPainter subvideo length",
+                                minimum=10,
+                                maximum=100,
+                                value=DEFAULT_SUBVIDEO_LENGTH,
+                                step=5,
+                            )
+                            ref_stride = gr.Slider(
+                                label="ProPainter reference stride",
+                                minimum=1,
+                                maximum=20,
+                                value=DEFAULT_REF_STRIDE,
+                                step=1,
+                            )
+                        neighbor_length = gr.Slider(
+                            label="ProPainter neighbor length",
+                            minimum=2,
+                            maximum=30,
+                            value=DEFAULT_NEIGHBOR_LENGTH,
+                            step=2,
                         )
-                    neighbor_length = gr.Slider(
-                        label="ProPainter neighbor length",
-                        minimum=2,
-                        maximum=30,
-                        value=DEFAULT_NEIGHBOR_LENGTH,
-                        step=2,
-                    )
 
                 with gr.Row():
                     submit_btn = gr.Button("Run", variant="primary")
@@ -1110,7 +1603,9 @@ with gr.Blocks() as demo:
                 video_result = gr.Video(label="Result", buttons=["download"])
                 with gr.Accordion("Debug outputs", open=False):
                     trimmed_video_result = gr.Video(label="Trimmed input video", interactive=False)
+                    refined_mask_result = gr.Video(label="Refined mask preview", interactive=False)
                     priori_result = gr.Video(label="ProPainter priori video", interactive=False)
+                    raw_diffueraser_result = gr.Video(label="Raw DiffuEraser result", interactive=False)
                     debug_log_file = gr.File(label="Debug log file", interactive=False)
                 gr.Examples(
                     examples=[
@@ -1128,6 +1623,9 @@ with gr.Blocks() as demo:
                 max_duration,
                 max_img_size,
                 mask_dilation_iter,
+                mask_refine_mode,
+                mask_refine_iterations,
+                mask_feather_px,
                 subvideo_length,
                 ref_stride,
                 neighbor_length,
@@ -1139,13 +1637,19 @@ with gr.Blocks() as demo:
                 guidance_scale,
                 zero_gpu_duration_mode,
                 zero_gpu_duration,
+                face_watermark_mode,
+                face_correction_strength,
                 prompt,
                 negative_prompt,
             ],
             outputs=[
+                settings_summary,
                 max_duration,
                 max_img_size,
                 mask_dilation_iter,
+                mask_refine_mode,
+                mask_refine_iterations,
+                mask_feather_px,
                 subvideo_length,
                 ref_stride,
                 neighbor_length,
@@ -1157,6 +1661,8 @@ with gr.Blocks() as demo:
                 guidance_scale,
                 zero_gpu_duration_mode,
                 zero_gpu_duration,
+                face_watermark_mode,
+                face_correction_strength,
                 prompt,
                 negative_prompt,
             ],
@@ -1165,7 +1671,7 @@ with gr.Blocks() as demo:
         clear_btn.click(
             fn=clear_inputs,
             inputs=None,
-            outputs=[input_video, input_mask, video_result, trimmed_video_result, priori_result, debug_log_file],
+            outputs=[input_video, input_mask, video_result, trimmed_video_result, refined_mask_result, priori_result, raw_diffueraser_result, debug_log_file],
         )
 
         submit_btn.click(
@@ -1175,6 +1681,9 @@ with gr.Blocks() as demo:
                 input_mask,
                 max_duration,
                 mask_dilation_iter,
+                mask_refine_mode,
+                mask_refine_iterations,
+                mask_feather_px,
                 max_img_size,
                 ref_stride,
                 neighbor_length,
@@ -1187,10 +1696,12 @@ with gr.Blocks() as demo:
                 guidance_scale,
                 zero_gpu_duration_mode,
                 zero_gpu_duration,
+                face_watermark_mode,
+                face_correction_strength,
                 prompt,
                 negative_prompt,
             ],
-            outputs=[video_result, trimmed_video_result, priori_result, debug_log_file],
+            outputs=[video_result, trimmed_video_result, refined_mask_result, priori_result, raw_diffueraser_result, debug_log_file],
         )
 
 demo.queue().launch(show_error=True, ssr_mode=False)