u

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

app.py

@@ -1,63 +1,116 @@
+from pathlib import Path
 import gradio as gr
-import json, os, subprocess, tempfile, shlex, mimetypes
+import kenburns as kb 
+import tempfile, shutil
 
-def load_effects(path="assets"):
-    effects = {}
-    for file in os.listdir(path):
-        if file.endswith(".json"):
-            with open(os.path.join(path, file), encoding="utf-8") as f:
-                for e in json.load(f).get("effects", []):
-                    effects[e["name"]] = e["command"]
-    return effects
+# ---------------------------------------------------------------------------
+# 1.  Helpers
+# ---------------------------------------------------------------------------
+TMP_DIR = Path(tempfile.gettempdir()) / "kb_ui"
+TMP_DIR.mkdir(exist_ok=True, parents=True)
 
-EFFECTS = load_effects()
+EXAMPLE_DIR = Path(__file__).parent.parent / "examples"
+EXAMPLE_SETS = [
+    [str(p) for p in sorted((EXAMPLE_DIR / "set1").glob("*.jpg"))],
+    [str(p) for p in sorted((EXAMPLE_DIR / "set2").glob("*.jpg"))],
+]
 
-def get_command(name): return EFFECTS.get(name, "")
+STYLE_OPTIONS = [
+    ("Random all", "*"),
+    ("Random zoom preset (one for ALL slides)", "zoom_*"),
+    ("Random zoom preset (DIFFERENT per slide)", "zoom_*!"),
+    ("Random pan preset (all)", "pan_*"),
+    ("Random pan preset (diff per slide)", "pan_*!"),
+]
+
+
+def build_preview(files):
+    """Return list of file paths for Gallery"""
+    return [f.name for f in files] if files else None
+
+
+# Gradio runner -------------------------------------------------------------
+
+def run_slideshow(files, dur, style_pattern, fps, cf, seed, progress=gr.Progress()):
+    if not files:
+        return None, None, "⚠️ Please upload or select example images."
+
+    # ensure reproducible paths & order
+    image_paths = [f.name for f in files]
+    durations = [dur] * len(image_paths)
+
+    out_path = TMP_DIR / "slideshow.mp4"
 
-def run_ffmpeg(input_path, command_str, output_ext):
-    out = tempfile.NamedTemporaryFile(suffix=output_ext, delete=False).name
-    args = ["ffmpeg", "-y", "-i", input_path] + shlex.split(command_str) + ["-preset", "ultrafast", out]
     try:
-        subprocess.run(args, check=True)
-        return "✅ Hiệu ứng đã tạo", out, " ".join(args)
-    except subprocess.CalledProcessError as e:
-        return f"❌ Lỗi FFmpeg: {e}", None, " ".join(args)
-
-def apply_effect(file, command, out_type):
-    if not file:
-        return "❌ Chưa chọn file", None, ""
-    ext = ".gif" if out_type == "GIF" else ".mp4"
-    return run_ffmpeg(file.name, command, ext)
-
-def preview_media(file):
-    if not file:
-        return None, None
-    mime, _ = mimetypes.guess_type(file.name)
-    if mime and mime.startswith("image"):
-        return file.name, None
-    elif mime and mime.startswith("video"):
-        return None, file.name
-    return None, None
-
-with gr.Blocks() as app:
-    gr.Markdown("🎞️ **Hiệu ứng video bằng FFmpeg từ file JSON**")
-
-    f = gr.File(label="Tệp ảnh/video", file_types=["image", "video"])
-    t = gr.Radio(["MP4", "GIF"], value="MP4", label="Loại đầu ra")
-    name_select = gr.Dropdown(choices=list(EFFECTS), label="Hoặc chọn hiệu ứng")
-    cmd_box = gr.Textbox(label="Lệnh FFmpeg", lines=2)
-    log_box = gr.Textbox(label="Log", lines=2, interactive=False)
-    msg = gr.Textbox(label="Trạng thái")
-
-    with gr.Row():
-        preview_img = gr.Image(label="Ảnh đã chọn", visible=False)
-        preview_vid = gr.Video(label="Video đã chọn", visible=False)
-
-    out = gr.Video(label="Kết quả")
-    btn = gr.Button("Tạo hiệu ứng")
-
-    name_select.change(get_command, name_select, cmd_box)
-    f.change(preview_media, f, [preview_img, preview_vid])
-    btn.click(apply_effect, [f, cmd_box, t], [msg, out, log_box])
-
-app.launch()
+        # show spinner/progress while FFmpeg runs
+        with progress.tqdm(desc="Rendering", total=1) as pbar:
+            vid_path, cmd = kb.generate_video(
+                image_paths,
+                durations,
+                style=style_pattern,
+                fps=fps,
+                cf=cf,
+                seed=(seed if seed else None),
+                out=str(out_path),
+            )
+            pbar.update()
+        return str(vid_path), cmd, "✅ Done"
+    except Exception as exc:
+        return None, None, f"❌ Error: {exc}"
+
+
+# Gradio interface ----------------------------------------------------------
+
+def launch():
+    with gr.Blocks(title="Ken Burns Slideshow (v2)") as demo:
+        gr.Markdown("## 🖼️ Ken Burns Slideshow Generator")
+
+        # --- Upload and preview ------------------------------------------
+        with gr.Row():
+            file_uploader = gr.File(
+                label="Upload images (drag to reorder in your OS before upload)",
+                file_count="multiple",
+                interactive=True,
+            )
+            gallery = gr.Gallery(label="Preview", show_label=True).style(grid=4)
+        file_uploader.upload(build_preview, file_uploader, gallery)
+
+        # --- Examples ----------------------------------------------------
+        gr.Examples(
+            examples=EXAMPLE_SETS,
+            inputs=file_uploader,
+            label="🖼️ Use example image sets (click to load)",
+        )
+
+        # --- Parameters --------------------------------------------------
+        with gr.Column():
+            dur_slider = gr.Slider(3, 15, value=6, step=0.5, label="Seconds per image")
+            style_dropdown = gr.Dropdown(
+                choices=[o[1] for o in STYLE_OPTIONS],
+                value="*",
+                label="Style pattern",
+                info="* = fully random | zoom_* = random zoom preset | zoom_*! = random zoom per slide",
+            )
+
+        with gr.Accordion("Advanced settings", open=False):
+            fps_slider = gr.Slider(15, 60, value=30, step=5, label="FPS")
+            cf_slider = gr.Slider(0.05, 0.3, value=0.15, step=0.01, label="Cross‑fade factor (0‑1)")
+            seed_num = gr.Number(value=0, label="Random seed (0 = random each run)")
+
+        # --- Output ------------------------------------------------------
+        out_video = gr.Video(label="Output video")
+        ff_cmd_box = gr.Textbox(label="FFmpeg command", lines=3)
+        status_box = gr.Textbox(label="Status / Errors", interactive=False)
+
+        run_btn = gr.Button("Generate 🎬")
+        run_btn.click(
+            run_slideshow,
+            inputs=[file_uploader, dur_slider, style_dropdown, fps_slider, cf_slider, seed_num],
+            outputs=[out_video, ff_cmd_box, status_box],
+        )
+
+    demo.launch()
+
+
+if __name__ == "__main__":
+    launch()

assets/3d_perspective.json

@@ -1,146 +0,0 @@
-{
-  "category": "3d_perspective",
-  "tags": ["3d", "perspective", "fisheye", "barrel", "distortion", "warp", "transform", "projection"],
-  "effects": [
-    {
-      "name": "Fisheye Lens Effect",
-      "command": "-vf \"v360=input=flat:output=fisheye:ih_fov=60:iv_fov=60\"",
-      "preview_url": "",
-      "description": "Create fisheye lens distortion effect",
-      "input": "video or image",
-      "rating": {
-        "popularity": 3.8,
-        "visual_impact": 4.5,
-        "ease_of_use": 3.5,
-        "creativity": 4.2
-      },
-      "tags": ["fisheye", "distortion", "wide-angle", "curved"]
-    },
-    {
-      "name": "Barrel Distortion",
-      "command": "-vf \"lenscorrection=k1=0.15:k2=0.05\"",
-      "preview_url": "",
-      "description": "Barrel distortion for vintage lens effect",
-      "input": "video or image",
-      "rating": {
-        "popularity": 3.2,
-        "visual_impact": 3.8,
-        "ease_of_use": 3.0,
-        "creativity": 4.0
-      },
-      "tags": ["barrel", "vintage", "lens", "curved"]
-    },
-    {
-      "name": "Pincushion Distortion", 
-      "command": "-vf \"lenscorrection=k1=-0.15:k2=-0.05\"",
-      "preview_url": "",
-      "description": "Pincushion distortion effect",
-      "input": "video or image",
-      "rating": {
-        "popularity": 2.8,
-        "visual_impact": 3.5,
-        "ease_of_use": 3.0,
-        "creativity": 3.8
-      },
-      "tags": ["pincushion", "inward", "distortion", "telephoto"]
-    },
-    {
-      "name": "Fisheye to Flat",
-      "command": "-vf \"v360=input=fisheye:output=flat:ih_fov=180:iv_fov=180\"",
-      "preview_url": "",
-      "description": "Convert fisheye footage to flat perspective",
-      "input": "fisheye video or image",
-      "rating": {
-        "popularity": 4.0,
-        "visual_impact": 3.2,
-        "ease_of_use": 3.8,
-        "creativity": 2.5
-      },
-      "tags": ["correction", "flat", "unfisheye", "normalize"]
-    },
-    {
-      "name": "360 to Equirectangular",
-      "command": "-vf \"v360=input=dfisheye:output=e:yaw=-90\"",
-      "preview_url": "",
-      "description": "Convert dual fisheye 360 to equirectangular format",
-      "input": "360 dual fisheye video",
-      "rating": {
-        "popularity": 3.5,
-        "visual_impact": 3.0,
-        "ease_of_use": 3.2,
-        "creativity": 2.8
-      },
-      "tags": ["360", "equirectangular", "vr", "panorama"]
-    },
-    {
-      "name": "Perspective Rotation",
-      "command": "-vf \"v360=input=flat:output=flat:pitch=20:yaw=15:roll=5\"",
-      "preview_url": "",
-      "description": "Rotate perspective in 3D space",
-      "input": "video or image",
-      "rating": {
-        "popularity": 2.5,
-        "visual_impact": 3.8,
-        "ease_of_use": 3.0,
-        "creativity": 4.5
-      },
-      "tags": ["3d", "rotation", "pitch", "yaw", "roll"]
-    },
-    {
-      "name": "Lens Correction",
-      "command": "-vf \"lenscorrection=k1=-0.227:k2=-0.022\"",
-      "preview_url": "",
-      "description": "Correct lens distortion from real cameras",
-      "input": "distorted video or image",
-      "rating": {
-        "popularity": 3.8,
-        "visual_impact": 2.5,
-        "ease_of_use": 2.8,
-        "creativity": 2.0
-      },
-      "tags": ["correction", "undistort", "calibration", "fix"]
-    },
-    {
-      "name": "Spherical Perspective",
-      "command": "-vf \"v360=input=flat:output=sg:h_fov=90:v_fov=90\"",
-      "preview_url": "",
-      "description": "Map flat image to spherical perspective",
-      "input": "video or image",
-      "rating": {
-        "popularity": 2.2,
-        "visual_impact": 4.0,
-        "ease_of_use": 2.8,
-        "creativity": 4.7
-      },
-      "tags": ["spherical", "planet", "globe", "wrap"]
-    },
-    {
-      "name": "VR Projection",
-      "command": "-vf \"v360=input=equirect:output=cubemap_3_2\"",
-      "preview_url": "",
-      "description": "Convert equirectangular to VR cubemap format",
-      "input": "360 equirectangular video",
-      "rating": {
-        "popularity": 3.0,
-        "visual_impact": 3.2,
-        "ease_of_use": 3.5,
-        "creativity": 3.5
-      },
-      "tags": ["vr", "cubemap", "projection", "format"]
-    },
-    {
-      "name": "Tiny Planet Effect",
-      "command": "-vf \"v360=input=equirect:output=sg:pitch=90\"",
-      "preview_url": "",
-      "description": "Create tiny planet effect from 360 footage",
-      "input": "360 equirectangular video",
-      "rating": {
-        "popularity": 3.8,
-        "visual_impact": 4.8,
-        "ease_of_use": 4.0,
-        "creativity": 4.9
-      },
-      "tags": ["tiny-planet", "stereographic", "miniature", "creative"]
-    }
-  ]
-}

assets/light_effect.json

@@ -1,205 +0,0 @@
-{
-    "category": "light_effects",
-    "tags": [
-        "light",
-        "glow",
-        "blur",
-        "flare",
-        "radial",
-        "lens",
-        "bright",
-        "illuminate"
-    ],
-    "effects": [
-        {
-            "name": "Gaussian Blur Glow",
-            "command": "-vf \"gblur=sigma=10\"",
-            "preview_url": "",
-            "description": "Soft gaussian blur for dreamy glow effect",
-            "input": "video or image",
-            "rating": {
-                "popularity": 4.2,
-                "visual_impact": 3.8,
-                "ease_of_use": 5.0,
-                "creativity": 3.0
-            },
-            "tags": [
-                "gaussian",
-                "blur",
-                "soft",
-                "dreamy"
-            ]
-        },
-        {
-            "name": "Box Blur Glow",
-            "command": "-vf \"boxblur=10\"",
-            "preview_url": "",
-            "description": "Box blur for bokeh-like camera effect",
-            "input": "video or image",
-            "rating": {
-                "popularity": 3.8,
-                "visual_impact": 3.5,
-                "ease_of_use": 5.0,
-                "creativity": 2.8
-            },
-            "tags": [
-                "box",
-                "blur",
-                "bokeh",
-                "camera"
-            ]
-        },
-        {
-            "name": "Intense Glow",
-            "command": "-vf \"gblur=sigma=20:steps=3\"",
-            "preview_url": "",
-            "description": "Strong glow effect with multiple blur steps",
-            "input": "video or image",
-            "rating": {
-                "popularity": 3.5,
-                "visual_impact": 4.2,
-                "ease_of_use": 4.5,
-                "creativity": 3.5
-            },
-            "tags": [
-                "intense",
-                "glow",
-                "strong",
-                "multiple"
-            ]
-        },
-        {
-            "name": "Radial Blur Zoom",
-            "command": "-vf \"crop=iw-40:ih-40:20:20,scale=iw:ih,gblur=sigma=5\"",
-            "preview_url": "",
-            "description": "Radial blur effect simulating motion towards center",
-            "input": "video or image",
-            "rating": {
-                "popularity": 3.2,
-                "visual_impact": 4.0,
-                "ease_of_use": 3.8,
-                "creativity": 4.2
-            },
-            "tags": [
-                "radial",
-                "motion",
-                "zoom",
-                "center"
-            ]
-        },
-        {
-            "name": "Brightness Explosion",
-            "command": "-vf \"eq=brightness=0.3:contrast=1.5,gblur=sigma=8\"",
-            "preview_url": "",
-            "description": "Bright explosion effect with glow",
-            "input": "video or image",
-            "rating": {
-                "popularity": 3.0,
-                "visual_impact": 4.3,
-                "ease_of_use": 4.0,
-                "creativity": 4.0
-            },
-            "tags": [
-                "explosion",
-                "bright",
-                "dramatic",
-                "energy"
-            ]
-        },
-        {
-            "name": "Selective Blur Glow",
-            "command": "-vf \"smartblur=1.0:0.8:0\"",
-            "preview_url": "",
-            "description": "Smart blur that preserves edges while creating glow",
-            "input": "video or image",
-            "rating": {
-                "popularity": 2.8,
-                "visual_impact": 3.8,
-                "ease_of_use": 3.5,
-                "creativity": 3.8
-            },
-            "tags": [
-                "smart",
-                "selective",
-                "edges",
-                "preserve"
-            ]
-        },
-        {
-            "name": "Soft Light Halo",
-            "command": "-vf \"gblur=sigma=15,eq=brightness=0.1:contrast=0.9\"",
-            "preview_url": "",
-            "description": "Soft halo effect around subjects",
-            "input": "video or image",
-            "rating": {
-                "popularity": 3.5,
-                "visual_impact": 4.0,
-                "ease_of_use": 4.2,
-                "creativity": 3.7
-            },
-            "tags": [
-                "halo",
-                "soft",
-                "angelic",
-                "portrait"
-            ]
-        },
-        {
-            "name": "Lens Flare Simulation",
-            "command": "-vf \"eq=brightness=0.2:contrast=1.3,gblur=sigma=12\"",
-            "preview_url": "",
-            "description": "Basic lens flare simulation with brightness and blur",
-            "input": "video or image",
-            "rating": {
-                "popularity": 4.0,
-                "visual_impact": 4.2,
-                "ease_of_use": 4.5,
-                "creativity": 3.8
-            },
-            "tags": [
-                "lens-flare",
-                "simulation",
-                "cinematic",
-                "bright"
-            ]
-        },
-        {
-            "name": "Moonlight Glow",
-            "command": "-vf \"eq=brightness=-0.1:contrast=0.8,gblur=sigma=6,hue=h=240\"",
-            "preview_url": "",
-            "description": "Soft moonlight effect with blue tint and glow",
-            "input": "video or image",
-            "rating": {
-                "popularity": 3.2,
-                "visual_impact": 4.1,
-                "ease_of_use": 4.0,
-                "creativity": 4.3
-            },
-            "tags": [
-                "moonlight",
-                "blue",
-                "night",
-                "romantic"
-            ]
-        },
-        {
-            "name": "Golden Hour Glow",
-            "command": "-vf \"eq=brightness=0.15:saturation=1.2,gblur=sigma=4,colortemperature=temperature=3000\"",
-            "preview_url": "",
-            "description": "Warm golden hour lighting with soft glow",
-            "input": "video or image",
-            "rating": {
-                "popularity": 4.5,
-                "visual_impact": 4.6,
-                "ease_of_use": 4.2,
-                "creativity": 4.0
-            },
-            "tags": [
-                "golden-hour",
-                "warm",
-                "sunset",
-                "cinematic"
-            ]
-        }
-    ]
-}

kenburns.py

@@ -0,0 +1,252 @@
+from __future__ import annotations
+
+import json
+import fnmatch
+import random
+import shlex
+import subprocess
+from dataclasses import dataclass
+from functools import lru_cache
+from math import cos, pi
+from pathlib import Path
+from typing import Dict, List, Sequence, Tuple, Union
+
+################################################################################
+# Domain models
+################################################################################
+
+@dataclass(frozen=True, slots=True)
+class Preset:
+    kind: str
+    start: float | None = None
+    end: float | None = None
+    anchor: str | None = None
+    dx: float | None = None
+    dy: float | None = None
+    rot_start: float | None = None
+    rot_end: float | None = None
+    ease: str = "linear"
+
+    @staticmethod
+    def from_dict(d: Dict) -> "Preset":
+        return Preset(**{k: v for k, v in d.items() if k in Preset.__dataclass_fields__})
+
+@dataclass(slots=True)
+class Slide:
+    path: str
+    duration: float
+    preset_name: str
+
+################################################################################
+# Template loader & style picker
+################################################################################
+
+ROOT = Path(__file__).resolve().parent
+_TEMPLATE_FILE = ROOT / "motion.json"
+
+@lru_cache(maxsize=1)
+def load_templates(path: Union[str, Path] = _TEMPLATE_FILE) -> Dict[str, Preset]:
+    try:
+        data = json.loads(Path(path).read_text("utf-8"))
+        return {k: Preset.from_dict(v) for k, v in data.items()}
+    except (FileNotFoundError, json.JSONDecodeError, TypeError) as e:
+        raise ValueError(f"Failed to load templates: {e}")
+
+def pick_styles(n: int, pattern: str = "*", *, seed: int | None = None,
+                presets: Dict[str, Preset] | None = None) -> List[str]:
+    if n <= 0:
+        raise ValueError(f"n must be positive, got {n}")
+    
+    db = presets or load_templates()
+    many = pattern.endswith("!")
+    pat = pattern[:-1] if many else pattern
+    pool = [k for k in db if pat == "*" or fnmatch.fnmatch(k, pat)]
+    
+    if not pool:
+        available = list(db.keys())[:5]  # Show first 5
+        raise ValueError(f"No preset matches '{pat}'. Available: {available}...")
+    
+    rng = random.Random(seed)
+    return [rng.choice(pool) for _ in range(n)] if (many or pat == "*") else [rng.choice(pool)] * n
+
+################################################################################
+# Low‑level helpers
+################################################################################
+
+def _ease(expr: str, mode: str) -> str:
+    easing_funcs = {
+        "linear": lambda e: e,
+        "ease-in": lambda e: f"({e})*({e})",
+        "ease-out": lambda e: f"1-((1-({e}))*(1-({e})))",
+        "ease-in-out": lambda e: f"(0.5-0.5*cos(pi*({e})))"
+    }
+    return easing_funcs.get(mode, easing_funcs["linear"])(expr)
+
+_ANCHOR_MAP = {
+    "center": ("iw/2-(iw/zoom/2)", "ih/2-(ih/zoom/2)"),
+    "left_top": ("0", "0"),
+    "right_bottom": ("iw-iw/zoom", "ih-ih/zoom"),
+    "left_center": ("0", "ih/2-(ih/zoom/2)"),
+    "right_center": ("iw-iw/zoom", "ih/2-(ih/zoom/2)"),
+    "center_top": ("iw/2-(iw/zoom/2)", "0"),
+    "center_bottom": ("iw/2-(iw/zoom/2)", "ih-ih/zoom"),
+}
+
+def _anchor(a: str) -> Tuple[str, str]:
+    return _ANCHOR_MAP.get(a, _ANCHOR_MAP["center"])
+
+################################################################################
+# Preset → zoompan string
+################################################################################
+
+def to_zoompan(p: Preset, frames: int) -> str:
+    if frames <= 0:
+        raise ValueError(f"frames must be positive, got {frames}")
+    
+    t = _ease(f"in/{frames}", p.ease)
+    
+    # Validation helpers
+    def require(*fields):
+        missing = [f for f in fields if getattr(p, f) is None]
+        if missing:
+            raise ValueError(f"{p.kind} preset missing: {missing}")
+    
+    # Zoom operations
+    if p.kind == "zoom":
+        require("start", "end")
+        z = f"'{p.start}+({p.end-p.start})*({t})'"
+        x, y = _anchor(p.anchor or "center")
+        return f"zoompan=z={z}:x='{x}':y='{y}':d={frames},setsar=1"
+    
+    # Pan operations
+    elif p.kind == "pan":
+        require("dx", "dy")
+        x, y = f"'{p.dx}*iw*({t})'", f"'{p.dy}*ih*({t})'"
+        return f"zoompan=z='1':x={x}:y={y}:d={frames},setsar=1"
+    
+    # Combined operations
+    elif p.kind == "zoom_pan":
+        require("start", "end", "dx", "dy")
+        z = f"'{p.start}+({p.end-p.start})*({t})'"
+        x = f"'iw/2-(iw/zoom/2)+{p.dx}*iw*({t})'"
+        y = f"'ih/2-(ih/zoom/2)+{p.dy}*ih*({t})'"
+        return f"zoompan=z={z}:x={x}:y={y}:d={frames},setsar=1"
+    
+    elif p.kind == "zoom_rotate":
+        require("start", "end", "rot_start", "rot_end")
+        z = f"'{p.start}+({p.end-p.start})*({t})'"
+        x, y = _anchor(p.anchor or "center")
+        rot = f"rotate={p.rot_start}+({p.rot_end-p.rot_start})*({t})"
+        return f"zoompan=z={z}:x='{x}':y='{y}':d={frames},setsar=1,{rot}"
+    
+    elif p.kind == "zoom_pan_rotate":
+        require("start", "end", "dx", "dy", "rot_start", "rot_end")
+        z = f"'{p.start}+({p.end-p.start})*({t})'"
+        x = f"'iw/2-(iw/zoom/2)+{p.dx}*iw*({t})'"
+        y = f"'ih/2-(ih/zoom/2)+{p.dy}*ih*({t})'"
+        rot = f"rotate={p.rot_start}+({p.rot_end-p.rot_start})*({t})"
+        return f"zoompan=z={z}:x={x}:y={y}:d={frames},setsar=1,{rot}"
+    
+    else:
+        valid_kinds = {"zoom", "pan", "zoom_pan", "zoom_rotate", "zoom_pan_rotate"}
+        raise ValueError(f"Unsupported kind '{p.kind}'. Valid: {valid_kinds}")
+
+################################################################################
+# FFmpeg command builder / runner
+################################################################################
+
+def _xfade_info(durs: Sequence[float], fx: float, lo: float = 0.1, hi: float = 1.0) -> Tuple[List[float], List[float]]:
+    if len(durs) < 2:
+        return [], []
+    
+    # Clamp crossfade duration to reasonable bounds
+    cf = [max(lo, min(hi, fx * min(durs[i], durs[i+1]))) for i in range(len(durs)-1)]
+    off = [durs[0]]
+    for i in range(1, len(durs)-1):
+        off.append(off[-1] + durs[i] - cf[i-1])
+    return cf, off
+
+def build_cmd(images: Sequence[str], durations: Sequence[float], *,
+              style: str = "*", fps: int = 30, cf_factor: float = 0.15,
+              seed: int | None = None, out: Union[str, Path] = "slideshow.mp4",
+              presets: Dict[str, Preset] | None = None) -> str:
+    
+    # Input validation
+    if len(images) != len(durations):
+        raise ValueError(f"Mismatch: {len(images)} images vs {len(durations)} durations")
+    if not images:
+        raise ValueError("No images provided")
+    if any(d <= 0 for d in durations):
+        bad_durs = [d for d in durations if d <= 0]
+        raise ValueError(f"All durations must be positive, got: {bad_durs}")
+    if fps <= 0:
+        raise ValueError(f"fps must be positive, got {fps}")
+    if not (0 <= cf_factor <= 1):
+        raise ValueError(f"cf_factor must be 0-1, got {cf_factor}")
+    
+    # Load presets and pick styles
+    db = presets or load_templates()
+    styles = pick_styles(len(images), style, seed=seed, presets=db)
+    
+    # Verify all styles exist
+    missing = [s for s in styles if s not in db]
+    if missing:
+        raise ValueError(f"Styles not found: {missing}")
+    
+    # Build filters
+    filters = []
+    for i, (img, dur, sname) in enumerate(zip(images, durations, styles)):
+        frames = max(1, int(dur * fps))  # Ensure at least 1 frame
+        filter_str = to_zoompan(db[sname], frames)
+        filters.append(f"[{i}:v]{filter_str}[v{i}]")
+    
+    # Handle single image case
+    if len(images) == 1:
+        fc = filters[0].replace("[v0]", "[vout]")
+    else:
+        # Build crossfade chain
+        cfs, ofs = _xfade_info(durations, cf_factor)
+        chain = []
+        for i in range(len(images) - 1):
+            left = "[v0]" if i == 0 else f"[x{i}]"
+            right = f"[v{i+1}]"
+            output = f"[x{i+1}]" if i < len(images) - 2 else "[vout]"
+            duration = cfs[i] if i < len(cfs) else 0.5
+            offset = ofs[i] if i < len(ofs) else 0.0
+            chain.append(f"{left}{right}xfade=transition=fade:duration={duration:.3f}:offset={offset:.3f}{output}")
+        fc = ";".join(filters + chain)
+    
+    # Build command
+    inputs = []
+    for img, d in zip(images, durations):
+        inputs.extend(['-loop', '1', '-t', str(d), '-i', str(img)])
+    
+    cmd_parts = [
+        "ffmpeg", *inputs,
+        "-filter_complex", fc,
+        "-map", "[vout]",
+        "-r", str(fps),
+        "-c:v", "libx264", "-preset", "veryfast", "-pix_fmt", "yuv420p",
+        "-y", str(out)
+    ]
+    
+    return shlex.join(cmd_parts)
+
+def generate_video(images: Sequence[str], durations: Sequence[float], **kw) -> Tuple[Path, str]:
+    # Check images exist
+    missing = [img for img in images if not Path(img).exists()]
+    if missing:
+        raise FileNotFoundError(f"Images not found: {missing}")
+    
+    cmd = build_cmd(images, durations, **kw)
+    output_path = Path(kw.get("out", "slideshow.mp4"))
+    
+    try:
+        subprocess.run(cmd, shell=True, check=True, 
+                      stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL)
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"FFmpeg failed (code {e.returncode}). Check: images exist, ffmpeg installed")
+    except FileNotFoundError:
+        raise FileNotFoundError("FFmpeg not found. Install ffmpeg and add to PATH")
+    
+    return output_path, cmd

motion.json

@@ -0,0 +1,171 @@
+{
+  "zoom_in_center": {
+    "kind": "zoom", "start": 1.00, "end": 1.30, "anchor": "center",
+    "ease": "linear",
+    "tags": ["focus", "calm", "intro"],
+    "desc": "Zoom-in 30 % giữ tâm ảnh, làm nổi bật nhân vật/đối tượng chính."
+  },
+  "zoom_out_center": {
+    "kind": "zoom", "start": 1.35, "end": 1.00, "anchor": "center",
+    "ease": "linear",
+    "tags": ["context", "reveal", "calm"],
+    "desc": "Zoom-out mở rộng khung cảnh, dùng sau cận cảnh để hé lộ bối cảnh."
+  },
+  "zoom_in_leftTop": {
+    "kind": "zoom", "start": 1.00, "end": 1.25, "anchor": "left_top",
+    "ease": "linear",
+    "tags": ["rule_of_thirds", "tension", "focus"],
+    "desc": "Zoom-in vào góc 1/3 trái-trên, tạo cảm giác bí ẩn hoặc căng thẳng nhẹ."
+  },
+  "zoom_in_rightBottom": {
+    "kind": "zoom", "start": 1.00, "end": 1.25, "anchor": "right_bottom",
+    "ease": "linear",
+    "tags": ["rule_of_thirds", "tension", "focus"],
+    "desc": "Zoom-in góc 1/3 phải-dưới, thích hợp nhấn mạnh chi tiết nhỏ."
+  },
+  "zoom_out_leftBottom": {
+    "kind": "zoom", "start": 1.30, "end": 1.00, "anchor": "left_bottom",
+    "ease": "linear",
+    "tags": ["reveal", "dramatic"],
+    "desc": "Zoom-out từ góc trái-dưới để lộ bố cục rộng."
+  },
+  "zoom_out_rightTop": {
+    "kind": "zoom", "start": 1.30, "end": 1.00, "anchor": "right_top",
+    "ease": "linear",
+    "tags": ["reveal", "dramatic"],
+    "desc": "Zoom-out từ góc phải-trên, tạo cảm giác thoát lên cao."
+  },
+
+  "pan_left":  {
+    "kind": "pan", "dx": -0.25, "dy": 0.00,
+    "ease": "linear",
+    "tags": ["flow", "dynamic", "reading_dir"],
+    "desc": "Trượt trái 25 % khung, dẫn mắt thuận chiều đọc (trái → phải)."
+  },
+  "pan_right": {
+    "kind": "pan", "dx": 0.25,  "dy": 0.00,
+    "ease": "linear",
+    "tags": ["flow", "dynamic", "reverse"],
+    "desc": "Trượt phải, hay dùng cho hồi tưởng hoặc nhân vật rời khung."
+  },
+  "pan_up":    {
+    "kind": "pan", "dx": 0.00,  "dy": -0.25,
+    "ease": "linear",
+    "tags": ["vertical", "reveal"],
+    "desc": "Pan-up 25 %: từ đất lên trời, mở khung cao."
+  },
+  "pan_down":  {
+    "kind": "pan", "dx": 0.00,  "dy": 0.25,
+    "ease": "linear",
+    "tags": ["vertical", "reveal"],
+    "desc": "Pan-down 25 %: từ trời xuống nhân vật/chi tiết."
+  },
+  "pan_diagonal_ul": {
+    "kind": "pan", "dx": -0.20, "dy": -0.20,
+    "ease": "linear",
+    "tags": ["diagonal", "energy", "comic"],
+    "desc": "Pan chéo lên-trái 20 %, tăng nhịp hành động."
+  },
+  "pan_diagonal_dr": {
+    "kind": "pan", "dx": 0.20, "dy": 0.20,
+    "ease": "linear",
+    "tags": ["diagonal", "energy", "comic"],
+    "desc": "Pan chéo xuống-phải, tạo cảm giác rơi/tuột nhanh."
+  },
+
+  "zoom_pan_left": {
+    "kind": "zoom_pan",
+    "start": 1.00, "end": 1.25, "dx": -0.20, "dy": 0.00,
+    "ease": "linear",
+    "tags": ["combo", "immersive"],
+    "desc": "Vừa pan trái vừa zoom-in 25 %, hiệu ứng dolly-tracking nhẹ."
+  },
+  "zoom_pan_right": {
+    "kind": "zoom_pan",
+    "start": 1.00, "end": 1.25, "dx": 0.20, "dy": 0.00,
+    "ease": "linear",
+    "tags": ["combo", "immersive"],
+    "desc": "Pan phải + zoom-in, hướng ánh nhìn theo chuyển động nhân vật."
+  },
+  "zoom_pan_up": {
+    "kind": "zoom_pan",
+    "start": 1.00, "end": 1.25, "dx": 0.00, "dy": -0.20,
+    "ease": "linear",
+    "tags": ["combo", "vertical"],
+    "desc": "Kéo lên trên và phóng to nhẹ, gợi cảm giác vươn cao."
+  },
+  "zoom_pan_down": {
+    "kind": "zoom_pan",
+    "start": 1.00, "end": 1.25, "dx": 0.00, "dy": 0.20,
+    "ease": "linear",
+    "tags": ["combo", "vertical"],
+    "desc": "Kéo xuống và phóng to nhẹ – phù hợp chuyển cảnh sky-to-subject."
+  },
+  "zoom_pan_diag_ul": {
+    "kind": "zoom_pan",
+    "start": 1.00, "end": 1.30, "dx": -0.15, "dy": -0.15,
+    "ease": "linear",
+    "tags": ["combo", "diagonal", "adventure"],
+    "desc": "Zoom + pan chéo lên-trái; dùng cho đoạn cao trào, phiêu lưu."
+  },
+  "zoom_pan_diag_dr": {
+    "kind": "zoom_pan",
+    "start": 1.00, "end": 1.30, "dx": 0.15, "dy": 0.15,
+    "ease": "linear",
+    "tags": ["combo", "diagonal", "adventure"],
+    "desc": "Zoom + pan chéo xuống-phải; nhấn tốc độ và hướng rơi."
+  },
+
+  "rotate_zoom_cw": {
+    "kind": "zoom_rotate",
+    "start": 1.00, "end": 1.25,
+    "rot_start": 0, "rot_end": 3,
+    "anchor": "center",
+    "ease": "linear",
+    "tags": ["drama", "unsettle"],
+    "desc": "Zoom-in kèm xoay 3° chiều kim đồng hồ, gợi cảm giác bất ổn."
+  },
+  "rotate_zoom_ccw": {
+    "kind": "zoom_rotate",
+    "start": 1.00, "end": 1.25,
+    "rot_start": 0, "rot_end": -3,
+    "anchor": "center",
+    "ease": "linear",
+    "tags": ["drama", "unsettle"],
+    "desc": "Zoom-in kèm xoay 3° ngược kim đồng hồ, tăng căng thẳng."
+  },
+
+  "parallax_left": {
+    "kind": "zoom_pan_rotate",
+    "start": 1.00, "end": 1.20,
+    "dx": -0.12, "dy": 0.00,
+    "rot_start": 0, "rot_end": 2,
+    "anchor": "center",
+    "ease": "linear",
+    "tags": ["parallax", "depth", "immersive"],
+    "desc": "Hiệu ứng parallax nhẹ: zoom-in + pan trái + xoay 2°."
+  },
+  "parallax_right": {
+    "kind": "zoom_pan_rotate",
+    "start": 1.00, "end": 1.20,
+    "dx": 0.12, "dy": 0.00,
+    "rot_start": 0, "rot_end": -2,
+    "anchor": "center",
+    "ease": "linear",
+    "tags": ["parallax", "depth", "immersive"],
+    "desc": "Parallax zoom-in + pan phải + xoay −2°."
+  },
+
+  "dolly_in_slow": {
+    "kind": "zoom", "start": 1.00, "end": 1.15, "anchor": "center",
+    "ease": "ease-in-out",
+    "tags": ["slow", "emotional", "close_up"],
+    "desc": "Zoom-in 15 % rất chậm (ease-in-out) cho khoảnh khắc cảm xúc."
+  },
+  "dolly_out_fast": {
+    "kind": "zoom", "start": 1.40, "end": 1.00, "anchor": "center",
+    "ease": "ease-out",
+    "tags": ["fast", "shock", "reveal"],
+    "desc": "Zoom-out 40 % nhanh (ease-out) tạo cú giật lùi, lộ plot-twist."
+  }
+}