up

app.py

@@ -1,115 +1,304 @@
-from pathlib import Path
 import gradio as gr
-import kenburns as kb 
-import tempfile, shutil
+import atexit
+from motion_processor import MotionProcessor
+from file_handler import FileHandler
+from video_processor import VideoProcessor
 
-# ---------------------------------------------------------------------------
-# 1.  Helpers
-# ---------------------------------------------------------------------------
-TMP_DIR = Path(tempfile.gettempdir()) / "kb_ui"
-TMP_DIR.mkdir(exist_ok=True, parents=True)
+# Initialize
+motion = MotionProcessor()
+files = FileHandler()
+processor = VideoProcessor(motion, files)
 
-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"))],
-]
+atexit.register(files.cleanup)
 
-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 preview_files(uploaded_files):
+    if not uploaded_files:
+        return None, "No files selected"
+    
+    file_list = files.get_files(uploaded_files)
+    preview = files.create_preview(file_list)
+    info = f"Found {len(file_list)} media files"
+    return preview, info
 
+def filter_templates_by_tag(tag_filter):
+    if tag_filter == "all":
+        filtered = motion.templates
+    else:
+        filtered = motion.get_templates_by_tag(tag_filter)
+    
+    choices = [f"{t['name']} ({', '.join(t.get('tags', []))})" for t in filtered]
+    return gr.Dropdown(choices=choices, value=choices[0] if choices else None)
 
-def build_preview(files):
-    """Return list of file paths for Gallery"""
-    return [f.name for f in files] if files else None
+def search_templates(search_query):
+    if not search_query.strip():
+        choices = [f"{t['name']} ({', '.join(t.get('tags', []))})" for t in motion.templates]
+    else:
+        filtered = motion.search_templates(search_query)
+        choices = [f"{t['name']} ({', '.join(t.get('tags', []))})" for t in filtered]
+    
+    return gr.Dropdown(choices=choices, value=choices[0] if choices else None)
 
+def test_single_effect(test_file, template_choice, aspect):
+    if not test_file or not template_choice:
+        return None, "Please upload a test file and select a template"
+    
+    template_name = template_choice.split(" (")[0]  # Extract name from "name (tags)"
+    
+    result, status = processor.test_effect(test_file.name, template_name, aspect)
+    return result, status
 
-# Gradio runner -------------------------------------------------------------
+def create_motion_video(input_files, aspect, output_format, use_random, selected_template, 
+                       workers, quality, fps, progress=gr.Progress()):
+    def progress_fn(val, desc):
+        progress(val, desc=desc)
+    
+    # Prepare template
+    template = None
+    if not use_random and selected_template:
+        template_name = selected_template.split(" (")[0]
+        template = next((t for t in motion.templates if t['name'] == template_name), None)
+    
+    # Advanced settings
+    advanced_settings = {
+        'workers': workers,
+        'quality': quality,
+        'fps': fps
+    }
+    
+    result, status = processor.create_video(
+        input_files, aspect, output_format, progress_fn, template, advanced_settings
+    )
+    
+    if result:
+        return result, status, gr.DownloadButton(label="📥 Download", value=result, visible=True)
+    return None, status, gr.DownloadButton(visible=False)
 
-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."
+def load_template(template_choice):
+    if not template_choice:
+        return "", 4, 1.0, 1.3, 0, 0, 0, 0, "", "", 0, 0
+    
+    template_name = template_choice.split(" (")[0]
+    template = next((t for t in motion.templates if t['name'] == template_name), motion.templates[0])
+    
+    return (
+        template['name'], 
+        template['duration'],
+        template['scale'][0], template['scale'][1],  # scale start, end
+        template['pan'][0], template['pan'][1],      # pan x1, y1
+        template['pan'][2], template['pan'][3],      # pan x2, y2
+        ', '.join(template.get('tags', [])),
+        template.get('desc', ''),
+        template['rotate'][0], template['rotate'][1]  # rotate start, end
+    )
 
-    # ensure reproducible paths & order
-    image_paths = [f.name for f in files]
-    durations = [dur] * len(image_paths)
+def save_template(name, duration, scale_start, scale_end, x1, y1, x2, y2, tags, desc, rot_start, rot_end):
+    if not name:
+        return "Enter template name", gr.Dropdown()
+    
+    tag_list = [tag.strip() for tag in tags.split(',') if tag.strip()] if tags else []
+    
+    new_template = {
+        'name': name, 
+        'duration': duration,
+        'scale': [scale_start, scale_end],
+        'pan': [x1, y1, x2, y2],
+        'rotate': [rot_start, rot_end],
+        'tags': tag_list,
+        'desc': desc or f"Custom template: {name}"
+    }
+    
+    # Update or add
+    existing = next((i for i, t in enumerate(motion.templates) if t['name'] == name), None)
+    if existing is not None:
+        motion.templates[existing] = new_template
+    else:
+        motion.templates.append(new_template)
+    
+    motion.save_templates(motion.templates)
+    choices = [f"{t['name']} ({', '.join(t.get('tags', []))})" for t in motion.templates]
+    return f"Saved '{name}'!", gr.Dropdown(choices=choices, value=f"{name} ({', '.join(tag_list)})")
 
-    out_path = TMP_DIR / "slideshow.mp4"
+# Get all unique tags
+all_tags = set()
+for template in motion.templates:
+    all_tags.update(template.get('tags', []))
+tag_choices = ["all"] + sorted(list(all_tags))
 
-    try:
-        # 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()
-
-
-launch()
+# Interface
+with gr.Blocks(title="Ken Burns Story Creator", css="""
+.gradio-container {max-width: 1400px !important}
+.compact-group {margin: 5px 0 !important}
+""") as app:
+    gr.Markdown("# 🎬 Ken Burns Story Creator\nCreate motion videos for YouTube, TikTok, Reels with 30+ effects")
+    
+    with gr.Tabs():
+        with gr.Tab("📹 Create Video"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    # Input
+                    files_input = gr.File(label="Upload Images/Videos", file_count="multiple", 
+                                        file_types=["image", "video"])
+                    
+                    # Preview
+                    with gr.Group():
+                        gr.Markdown("### Preview")
+                        preview_img = gr.Image(label="Files Preview", height=200)
+                        preview_info = gr.Textbox(label="Info", interactive=False)
+                    
+                    # Effect Selection
+                    with gr.Group():
+                        gr.Markdown("### 🎭 Effect Selection")
+                        
+                        with gr.Row():
+                            use_random = gr.Checkbox(label="Random Effects", value=True)
+                            
+                        with gr.Column(visible=False) as effect_selector:
+                            with gr.Row():
+                                tag_filter = gr.Dropdown(
+                                    choices=tag_choices, value="all",
+                                    label="Filter by Tag", scale=1
+                                )
+                                search_box = gr.Textbox(
+                                    label="Search Effects", placeholder="zoom, pan, dramatic...", scale=2
+                                )
+                            
+                            template_dropdown = gr.Dropdown(
+                                choices=[f"{t['name']} ({', '.join(t.get('tags', []))})" for t in motion.templates],
+                                label="Select Effect"
+                            )
+                    
+                    # Settings
+                    with gr.Row():
+                        aspect_ratio = gr.Dropdown(
+                            choices=['reels', 'tiktok', 'youtube', 'square', 'widescreen'],
+                            value='reels',
+                            label="📱 Platform"
+                        )
+                        output_format = gr.Radio(['mp4', 'gif'], value='mp4', label="Format")
+                
+                with gr.Column(scale=1):
+                    # Test Effect
+                    with gr.Group():
+                        gr.Markdown("### 🧪 Test Effect")
+                        test_file = gr.File(label="Test Image", file_types=["image"])
+                        test_btn = gr.Button("🎬 Test Effect", size="sm")
+                        test_result = gr.Video(label="Test Result", height=200)
+                        test_status = gr.Textbox(label="Test Status", interactive=False)
+                    
+                    # Create Video
+                    create_btn = gr.Button("🚀 Create Story", variant="primary", size="lg")
+                    status = gr.Textbox(label="Status", interactive=False)
+                    output_video = gr.Video(label="Result", height=300)
+                    download_btn = gr.DownloadButton(label="📥 Download", visible=False)
+        
+        with gr.Tab("⚙️ Advanced Settings"):
+            gr.Markdown("### Advanced Processing Settings")
+            
+            with gr.Row():
+                workers = gr.Slider(1, 8, value=4, step=1, label="🔄 Parallel Workers")
+                fps = gr.Slider(15, 60, value=25, step=5, label="🎞️ FPS")
+            
+            with gr.Row():
+                quality = gr.Dropdown(
+                    choices=['ultrafast', 'superfast', 'veryfast', 'faster', 'fast', 'medium', 'slow'],
+                    value='fast',
+                    label="🏆 Quality Preset"
+                )
+        
+        with gr.Tab("🎭 Templates"):
+            gr.Markdown("### Motion Templates Manager")
+            
+            with gr.Row():
+                with gr.Column(scale=2):
+                    template_dropdown_edit = gr.Dropdown(
+                        choices=[f"{t['name']} ({', '.join(t.get('tags', []))})" for t in motion.templates],
+                        value=f"{motion.templates[0]['name']} ({', '.join(motion.templates[0].get('tags', []))})",
+                        label="Template"
+                    )
+                    
+                    with gr.Row():
+                        name_input = gr.Textbox(label="Name", placeholder="template_name")
+                        duration_input = gr.Number(label="Duration (s)", value=4, minimum=2, maximum=10)
+                    
+                    with gr.Row():
+                        scale_start = gr.Number(label="Scale Start", value=1.0, step=0.1)
+                        scale_end = gr.Number(label="Scale End", value=1.3, step=0.1)
+                    
+                    with gr.Row():
+                        x1 = gr.Number(label="Pan X1", value=0)
+                        y1 = gr.Number(label="Pan Y1", value=0)
+                        x2 = gr.Number(label="Pan X2", value=0)
+                        y2 = gr.Number(label="Pan Y2", value=0)
+                    
+                    with gr.Row():
+                        rot_start = gr.Number(label="Rotate Start (°)", value=0)
+                        rot_end = gr.Number(label="Rotate End (°)", value=0)
+                    
+                    tags_input = gr.Textbox(
+                        label="Tags (comma separated)", 
+                        placeholder="zoom, left, dramatic",
+                        value=""
+                    )
+                    
+                    desc_input = gr.Textbox(
+                        label="Description",
+                        placeholder="Describe the motion effect...",
+                        lines=2
+                    )
+                    
+                    save_btn = gr.Button("💾 Save Template", variant="primary")
+                    template_status = gr.Textbox(label="Status", interactive=False)
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("### 📋 Available Tags")
+                    gr.Markdown(f"**{len(tag_choices)-1} unique tags:**")
+                    gr.Markdown(", ".join(sorted(tag_choices[1:])))  # Exclude "all"
+                    
+                    gr.Markdown("### 📖 Template Guide")
+                    gr.Markdown("""
+                    **Scale**: Zoom level (1.0 = normal)
+                    **Pan X1,Y1**: Start position  
+                    **Pan X2,Y2**: End position
+                    **Duration**: Effect length in seconds
+                    **Tags**: For easy searching
+                    """)
+        
+        with gr.Tab("ℹ️ Help"):
+            gr.Markdown(f"""
+            ### 📖 How to Use
+            1. **Upload** your images/videos
+            2. **Choose effects**: Random or specific template
+            3. **Test effects** on single image first
+            4. **Select platform** aspect ratio
+            5. **Create** your story video
+            
+            ### 🎭 Available Effects ({len(motion.templates)} total)
+            
+            **Zoom Effects:**
+            - Center zoom in/out
+            - Directional zooms (left, right, top, bottom)
+            - Dramatic push/pull effects
+            
+            **Pan Effects:**
+            - Horizontal/vertical pans
+            - Diagonal movements
+            - Arc and spiral motions
+            
+            **Cinematic Effects:**
+            - Slow drifts and breathing
+            - Focus shifts and reveals
+            - Documentary style movements
+            
+            ### 📱 Platform Settings
+            - **Reels/TikTok**: 9:16 (1080x1920)
+            - **YouTube**: 16:9 (1920x1080)
+            - **Square**: 1:1 (1080x1080)
+            
+            ### ⚙️ Advanced Settings
+            - **Workers**: Parallel processing (more = faster)
+            - **Quality**: FFmpeg preset (fast vs quality)
+            - **FPS**: Frame rate (higher = smoother)
+            """)
+    
+    # Events
+    files_input.change(preview_files, [files_input], [preview_img, preview_info])

motion.json

@@ -1,171 +1,326 @@
-{
-  "zoom_in_center": {
-    "kind": "zoom", "start": 1.00, "end": 1.30, "anchor": "center",
-    "ease": "linear",
+[
+  {
+    "name": "zoom_in_center",
+    "scale": [1.0, 1.3],
+    "pan": [0, 0, 0, 0],
+    "rotate": [0, 0],
+    "duration": 4,
     "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."
+    "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",
+  {
+    "name": "zoom_out_center",
+    "scale": [1.35, 1.0],
+    "pan": [0, 0, 0, 0],
+    "rotate": [0, 0],
+    "duration": 4,
     "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."
+    "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",
+  {
+    "name": "zoom_in_left_top",
+    "scale": [1.0, 1.25],
+    "pan": [50, 50, -30, -30],
+    "rotate": [0, 0],
+    "duration": 4,
     "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ẹ."
+    "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",
+  {
+    "name": "zoom_in_right_bottom",
+    "scale": [1.0, 1.25],
+    "pan": [-50, -50, 30, 30],
+    "rotate": [0, 0],
+    "duration": 4,
     "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ỏ."
+    "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",
+  {
+    "name": "zoom_out_left_bottom",
+    "scale": [1.3, 1.0],
+    "pan": [30, -30, 0, 0],
+    "rotate": [0, 0],
+    "duration": 4,
     "tags": ["reveal", "dramatic"],
-    "desc": "Zoom-out từ góc trái-dưới để lộ bố cục rộng."
+    "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",
+  {
+    "name": "zoom_out_right_top",
+    "scale": [1.3, 1.0],
+    "pan": [-30, 30, 0, 0],
+    "rotate": [0, 0],
+    "duration": 4,
     "tags": ["reveal", "dramatic"],
-    "desc": "Zoom-out từ góc phải-trên, tạo cảm giác thoát lên cao."
+    "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",
+  {
+    "name": "pan_left",
+    "scale": [1.2, 1.2],
+    "pan": [100, 0, -100, 0],
+    "rotate": [0, 0],
+    "duration": 5,
     "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)."
+    "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",
+  {
+    "name": "pan_right",
+    "scale": [1.2, 1.2],
+    "pan": [-100, 0, 100, 0],
+    "rotate": [0, 0],
+    "duration": 5,
     "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."
+    "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",
+  {
+    "name": "pan_up",
+    "scale": [1.2, 1.2],
+    "pan": [0, 80, 0, -80],
+    "rotate": [0, 0],
+    "duration": 5,
     "tags": ["vertical", "reveal"],
-    "desc": "Pan-up 25 %: từ đất lên trời, mở khung cao."
+    "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",
+  {
+    "name": "pan_down",
+    "scale": [1.2, 1.2],
+    "pan": [0, -80, 0, 80],
+    "rotate": [0, 0],
+    "duration": 5,
     "tags": ["vertical", "reveal"],
-    "desc": "Pan-down 25 %: từ trời xuống nhân vật/chi tiết."
+    "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",
+  {
+    "name": "pan_diagonal_ul",
+    "scale": [1.1, 1.1],
+    "pan": [60, 60, -60, -60],
+    "rotate": [0, 0],
+    "duration": 4,
     "tags": ["diagonal", "energy", "comic"],
-    "desc": "Pan chéo lên-trái 20 %, tăng nhịp hành động."
+    "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",
+  {
+    "name": "pan_diagonal_dr",
+    "scale": [1.1, 1.1],
+    "pan": [-60, -60, 60, 60],
+    "rotate": [0, 0],
+    "duration": 4,
     "tags": ["diagonal", "energy", "comic"],
-    "desc": "Pan chéo xuống-phải, tạo cảm giác rơi/tuột nhanh."
+    "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",
+  {
+    "name": "zoom_pan_left",
+    "scale": [1.0, 1.25],
+    "pan": [60, 0, -60, 0],
+    "rotate": [0, 0],
+    "duration": 4,
     "tags": ["combo", "immersive"],
-    "desc": "Vừa pan trái vừa zoom-in 25 %, hiệu ứng dolly-tracking nhẹ."
+    "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",
+  {
+    "name": "zoom_pan_right",
+    "scale": [1.0, 1.25],
+    "pan": [-60, 0, 60, 0],
+    "rotate": [0, 0],
+    "duration": 4,
     "tags": ["combo", "immersive"],
-    "desc": "Pan phải + zoom-in, hướng ánh nhìn theo chuyển động nhân vật."
+    "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",
+  {
+    "name": "zoom_pan_up",
+    "scale": [1.0, 1.25],
+    "pan": [0, 60, 0, -60],
+    "rotate": [0, 0],
+    "duration": 4,
     "tags": ["combo", "vertical"],
-    "desc": "Kéo lên trên và phóng to nhẹ, gợi cảm giác vươn cao."
+    "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",
+  {
+    "name": "zoom_pan_down",
+    "scale": [1.0, 1.25],
+    "pan": [0, -60, 0, 60],
+    "rotate": [0, 0],
+    "duration": 4,
     "tags": ["combo", "vertical"],
-    "desc": "Kéo xuống và phóng to nhẹ – phù hợp chuyển cảnh sky-to-subject."
+    "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",
+  {
+    "name": "zoom_pan_diag_ul",
+    "scale": [1.0, 1.3],
+    "pan": [45, 45, -45, -45],
+    "rotate": [0, 0],
+    "duration": 4,
     "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."
+    "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",
+  {
+    "name": "zoom_pan_diag_dr",
+    "scale": [1.0, 1.3],
+    "pan": [-45, -45, 45, 45],
+    "rotate": [0, 0],
+    "duration": 4,
     "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",
+    "desc": "Zoom + pan chéo xuống-phải; nhấn tốc độ và hướng rơi"
+  },
+  {
+    "name": "rotate_zoom_cw",
+    "scale": [1.0, 1.25],
+    "pan": [0, 0, 0, 0],
+    "rotate": [0, 3],
+    "duration": 4,
     "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",
+    "desc": "Zoom-in kèm xoay 3° chiều kim đồng hồ, gợi cảm giác bất ổn"
+  },
+  {
+    "name": "rotate_zoom_ccw",
+    "scale": [1.0, 1.25],
+    "pan": [0, 0, 0, 0],
+    "rotate": [0, -3],
+    "duration": 4,
     "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",
+    "desc": "Zoom-in kèm xoay 3° ngược kim đồng hồ, tăng căng thẳng"
+  },
+  {
+    "name": "parallax_left",
+    "scale": [1.0, 1.2],
+    "pan": [40, 0, -40, 0],
+    "rotate": [0, 2],
+    "duration": 5,
     "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",
+    "desc": "Hiệu ứng parallax nhẹ: zoom-in + pan trái + xoay 2°"
+  },
+  {
+    "name": "parallax_right",
+    "scale": [1.0, 1.2],
+    "pan": [-40, 0, 40, 0],
+    "rotate": [0, -2],
+    "duration": 5,
     "tags": ["parallax", "depth", "immersive"],
-    "desc": "Parallax zoom-in + pan phải + xoay −2°."
+    "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",
+  {
+    "name": "dolly_in_slow",
+    "scale": [1.0, 1.15],
+    "pan": [0, 0, 0, 0],
+    "rotate": [0, 0],
+    "duration": 6,
     "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."
+    "desc": "Zoom-in 15% rất chậm 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",
+  {
+    "name": "dolly_out_fast",
+    "scale": [1.4, 1.0],
+    "pan": [0, 0, 0, 0],
+    "rotate": [0, 0],
+    "duration": 3,
     "tags": ["fast", "shock", "reveal"],
-    "desc": "Zoom-out 40 % nhanh (ease-out) tạo cú giật lùi, lộ plot-twist."
+    "desc": "Zoom-out 40% nhanh tạo cú giật lùi, lộ plot-twist"
+  },
+  {
+    "name": "breathe_gentle",
+    "scale": [1.0, 1.08],
+    "pan": [0, 0, 0, 0],
+    "rotate": [0, 0],
+    "duration": 7,
+    "tags": ["subtle", "organic", "peaceful"],
+    "desc": "Zoom nhẹ như nhịp thở, tạo cảm giác sống động tự nhiên"
+  },
+  {
+    "name": "spiral_in",
+    "scale": [1.0, 1.35],
+    "pan": [30, 30, -30, -30],
+    "rotate": [0, 8],
+    "duration": 5,
+    "tags": ["spiral", "hypnotic", "intense"],
+    "desc": "Hiệu ứng xoắn ốc zoom-in kèm xoay 8°, tạo cảm giác mê hoặc"
+  },
+  {
+    "name": "spiral_out",
+    "scale": [1.35, 1.0],
+    "pan": [-30, -30, 30, 30],
+    "rotate": [8, 0],
+    "duration": 5,
+    "tags": ["spiral", "release", "dramatic"],
+    "desc": "Xoắn ốc ngược zoom-out từ 8° về 0°, giải phóng căng thẳng"
+  },
+  {
+    "name": "pendulum_left",
+    "scale": [1.05, 1.05],
+    "pan": [50, 0, -50, 0],
+    "rotate": [0, 0],
+    "duration": 6,
+    "tags": ["pendulum", "rhythm", "hypnotic"],
+    "desc": "Pan trái nhẹ nhàng như lắc lư, tạo nhịp điệu ru ngủ"
+  },
+  {
+    "name": "pendulum_right",
+    "scale": [1.05, 1.05],
+    "pan": [-50, 0, 50, 0],
+    "rotate": [0, 0],
+    "duration": 6,
+    "tags": ["pendulum", "rhythm", "hypnotic"],
+    "desc": "Pan phải nhẹ nhàng như lắc lư, đối xứng với pendulum_left"
+  },
+  {
+    "name": "tilt_dramatic",
+    "scale": [1.0, 1.0],
+    "pan": [0, 0, 0, 0],
+    "rotate": [0, 15],
+    "duration": 3,
+    "tags": ["tilt", "dramatic", "action"],
+    "desc": "Nghiêng camera 15° nhanh, tăng tính kịch tính hành động"
+  },
+  {
+    "name": "straighten",
+    "scale": [1.0, 1.0],
+    "pan": [0, 0, 0, 0],
+    "rotate": [15, 0],
+    "duration": 4,
+    "tags": ["stabilize", "calm", "resolution"],
+    "desc": "Từ nghiêng 15° về thẳng, tạo cảm giác ổn định trở lại"
+  },
+  {
+    "name": "vertigo_zoom",
+    "scale": [1.0, 1.5],
+    "pan": [0, 0, 0, 0],
+    "rotate": [0, 0],
+    "duration": 2,
+    "tags": ["vertigo", "shock", "intense"],
+    "desc": "Zoom-in 50% rất nhanh, tạo hiệu ứng vertigo gây choáng váng"
+  },
+  {
+    "name": "wide_sweep_left",
+    "scale": [1.1, 1.1],
+    "pan": [120, 0, -120, 0],
+    "rotate": [0, 0],
+    "duration": 6,
+    "tags": ["wide", "sweep", "panoramic"],
+    "desc": "Quét ngang rộng từ phải sang trái, hiệu ứng panorama"
+  },
+  {
+    "name": "wide_sweep_right",
+    "scale": [1.1, 1.1],
+    "pan": [-120, 0, 120, 0],
+    "rotate": [0, 0],
+    "duration": 6,
+    "tags": ["wide", "sweep", "panoramic"],
+    "desc": "Quét ngang rộng từ trái sang phải, mở rộng không gian"
+  },
+  {
+    "name": "intimate_close",
+    "scale": [1.0, 1.6],
+    "pan": [0, 0, -10, -10],
+    "rotate": [0, 0],
+    "duration": 3,
+    "tags": ["intimate", "close", "portrait"],
+    "desc": "Zoom-in sâu 60% tạo cảm giác thân mật, gần gũi"
+  },
+  {
+    "name": "documentary_drift",
+    "scale": [1.05, 1.2],
+    "pan": [-30, 10, 20, -15],
+    "rotate": [0, 1],
+    "duration": 5,
+    "tags": ["documentary", "natural", "organic"],
+    "desc": "Chuyển động tự nhiên như quay phim tài liệu"
   }
-}
+]

motion_processor.py

@@ -0,0 +1,115 @@
+import json
+import random
+import subprocess
+import math
+from pathlib import Path
+
+class MotionProcessor:
+    def __init__(self, motion_file="motion.json"):
+        self.motion_file = motion_file
+        self.templates = self._load_templates()
+        self.aspect_ratios = {
+            'youtube': '1920:1080',
+            'reels': '1080:1920',
+            'tiktok': '1080:1920', 
+            'square': '1080:1080',
+            'widescreen': '1920:1080'
+        }
+    
+    def _load_templates(self):
+        try:
+            return json.load(open(self.motion_file))
+        except:
+            return []
+    
+    def save_templates(self, templates):
+        json.dump(templates, open(self.motion_file, 'w'), indent=2)
+        self.templates = templates
+    
+    def get_random_template(self):
+        return random.choice(self.templates)
+    
+    def get_templates_by_tag(self, tag):
+        return [t for t in self.templates if tag.lower() in [tag.lower() for tag in t.get('tags', [])]]
+    
+    def search_templates(self, query):
+        query = query.lower()
+        return [t for t in self.templates 
+                if query in t['name'].lower() or 
+                any(query in tag.lower() for tag in t.get('tags', []))]
+    
+    def apply_motion(self, input_path, output_path, template=None, aspect='youtube', quality='fast', fps=25):
+        if not template:
+            template = self.get_random_template()
+        
+        resolution = self.aspect_ratios[aspect]
+        w, h = map(int, resolution.split(':'))
+        duration = template['duration']
+        
+        # Extract values - đơn giản
+        scale_start, scale_end = template['scale']
+        x1, y1, x2, y2 = template['pan']
+        rot_start, rot_end = template['rotate']
+        
+        # Build filter - logic đơn giản
+        total_frames = duration * fps
+        
+        filter_parts = [
+            f"[0:v]scale={w}:{h}:force_original_aspect_ratio=increase",
+            f"crop={w}:{h}"
+        ]
+        
+        # Zoom + Pan
+        if scale_start != scale_end or any([x1, y1, x2, y2]):
+            zoom_filter = (
+                f"zoompan=z='min({scale_start}+({scale_end}-{scale_start})*on/{total_frames},{scale_end})':"
+                f"d={total_frames}:"
+                f"x='iw/2-(iw/zoom/2)+({x1}+({x2}-{x1})*on/{total_frames})':"
+                f"y='ih/2-(ih/zoom/2)+({y1}+({y2}-{y1})*on/{total_frames})':"
+                f"s={w}x{h}:fps={fps}"
+            )
+            filter_parts.append(zoom_filter)
+        
+        # Rotation
+        if rot_start != rot_end:
+            rot_rad_start = math.radians(rot_start)
+            rot_rad_end = math.radians(rot_end)
+            rotate_filter = (
+                f"rotate='({rot_rad_start}+({rot_rad_end}-{rot_rad_start})*t/{duration})':"
+                f"c=black:ow={w}:oh={h}"
+            )
+            filter_parts.append(rotate_filter)
+        
+        filter_parts.append("[v]")
+        filter_complex = ",".join(filter_parts)
+        
+        cmd = [
+            'ffmpeg', '-y', '-i', input_path,
+            '-filter_complex', filter_complex,
+            '-map', '[v]', '-t', str(duration),
+            '-c:v', 'libx264', '-preset', quality, '-crf', '23',
+            output_path
+        ]
+        
+        subprocess.run(cmd, check=True, capture_output=True)
+        return output_path
+    
+    def concat_videos(self, video_files, output_path, output_format='mp4'):
+        list_file = "temp_list.txt"
+        with open(list_file, 'w') as f:
+            for v in video_files:
+                f.write(f"file '{v}'\n")
+        
+        if output_format == 'gif':
+            subprocess.run([
+                'ffmpeg', '-y', '-f', 'concat', '-safe', '0', '-i', list_file,
+                '-vf', 'fps=12,scale=640:-1:flags=lanczos', output_path
+            ], check=True, capture_output=True)
+        else:
+            subprocess.run([
+                'ffmpeg', '-y', '-f', 'concat', '-safe', '0', '-i', list_file,
+                '-c', 'copy', output_path
+            ], check=True, capture_output=True)
+        
+        Path(list_file).unlink(missing_ok=True)
+        return output_path

video_processor.py

@@ -0,0 +1,90 @@
+import os
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+class VideoProcessor:
+    def __init__(self, motion_processor, file_handler):
+        self.motion = motion_processor
+        self.files = file_handler
+    
+    def process_single(self, file_path, output_path, aspect):
+        try:
+            return self.motion.apply_motion(file_path, output_path, aspect=aspect)
+        except Exception as e:
+            print(f"Error processing {file_path}: {e}")
+            return None
+    
+    def create_video(self, input_files, aspect='youtube', output_format='mp4', progress_fn=None, 
+                    selected_template=None, advanced_settings=None):
+        files = self.files.get_files(input_files)
+        if not files:
+            return None, "No valid files found"
+
+        if progress_fn:
+            progress_fn(0.1, f"Processing {len(files)} files...")
+
+        # Process files parallel
+        segments_dir = self.files.temp_path("segments")
+        os.makedirs(segments_dir, exist_ok=True)
+
+        # Advanced settings
+        workers = advanced_settings.get('workers', 4) if advanced_settings else 4
+        quality = advanced_settings.get('quality', 'fast') if advanced_settings else 'fast'
+        fps = advanced_settings.get('fps', 25) if advanced_settings else 25
+
+        processed = []
+        with ThreadPoolExecutor(max_workers=workers) as executor:
+            futures = []
+            for i, file_path in enumerate(files):
+                output_path = os.path.join(segments_dir, f"seg_{i:03d}.mp4")
+                # Use selected template or random
+                template = selected_template if selected_template else None
+                future = executor.submit(self.process_single, file_path, output_path, aspect, template, quality, fps)
+                futures.append(future)
+
+            for future in futures:
+                result = future.result()
+                if result:
+                    processed.append(result)
+
+        if not processed:
+            return None, "Failed to process any files"
+
+        if progress_fn:
+            progress_fn(0.8, "Combining segments...")
+
+        # Combine videos
+        ext = 'gif' if output_format == 'gif' else 'mp4'
+        final_output = self.files.temp_path(f"final.{ext}")
+
+        self.motion.concat_videos(processed, final_output, output_format)
+
+        # Cleanup
+        for seg in processed:
+            try:
+                os.unlink(seg)
+            except:
+                pass
+
+        if progress_fn:
+            progress_fn(1.0, "Complete!")
+
+        return final_output, f"Created video from {len(files)} files"
+    
+    
+    def test_effect(self, test_file, template_name, aspect='youtube'):
+        """Test single effect on one file"""
+        if not test_file:
+            return None, "No test file provided"
+        
+        template = next((t for t in self.motion.templates if t['name'] == template_name), None)
+        if not template:
+            return None, f"Template '{template_name}' not found"
+        
+        test_output = self.files.temp_path(f"test_{template_name}.mp4")
+        
+        try:
+            result = self.motion.apply_motion(test_file, test_output, template, aspect)
+            return result, f"Test completed with '{template_name}' effect"
+        except Exception as e:
+            return None, f"Test failed: {str(e)}"