up

app.py

@@ -1,13 +1,16 @@
 import gradio as gr
 import atexit
-from typing import List, Tuple, Optional, Dict, Any, Union
+from typing import List, Tuple, Optional, Dict, Any
 
-from src import MotionProcessor, FileHandler, VideoProcessor
+from src.motion_processor import MotionProcessor
+from src.file_handler import FileHandler
+from src.video_processor import VideoProcessor
+from src.utils import estimate_output
 
-# Initialize with type hints
-motion: MotionProcessor = MotionProcessor()
-files: FileHandler = FileHandler()
-processor: VideoProcessor = VideoProcessor(motion, files)
+# Init
+motion = MotionProcessor()
+files = FileHandler()
+processor = VideoProcessor(motion, files)
 
 atexit.register(files.cleanup)
 
@@ -15,205 +18,186 @@ def preview_files(uploaded_files: Optional[List[Any]]) -> Tuple[Optional[str], s
     if not uploaded_files:
         return None, "No files selected"
     
-    file_list: List[str] = files.get_files(uploaded_files)
-    preview: Optional[str] = files.create_preview(file_list)
-    info: str = f"Found {len(file_list)} media files"
-    return preview, info
+    file_list, info = files.files_info(uploaded_files)
+    if not file_list:
+        return None, "No valid media files found"
+        
+    preview = files.preview(file_list)
+    
+    # Info display
+    parts = [
+        f"📊 Total: {info['total']} files ({info['size_mb']} MB)",
+        f"🖼️ Images: {info['images']} | 🎥 Videos: {info['videos']}"
+    ]
+    
+    if info['details']:
+        est = estimate_output(file_list)
+        parts.append(f"⏱️ Est. duration: {est['duration_fmt']}")
+        parts.append(f"📦 Est. size: ~{est['size_mb']} MB")
+    
+    return preview, "\n".join(parts)
+
+def template_choices() -> List[str]:
+    return [f"{t['name']} - {t.get('desc', '')[:50]}..." for t in motion.templates]
 
-def filter_templates_by_tag(tag_filter: str) -> gr.Dropdown:
-    if tag_filter == "all":
-        filtered: List[Dict[str, Any]] = motion.templates
+def filter_by_tag(tag: str) -> gr.Dropdown:
+    if tag == "all":
+        filtered = motion.templates
     else:
-        filtered = motion.get_templates_by_tag(tag_filter)
+        filtered = motion.by_tag(tag)
     
-    choices: List[str] = [f"{t['name']} - {t.get('desc', '')[:50]}..." for t in filtered]
+    choices = [f"{t['name']} - {t.get('desc', '')[:50]}..." for t in filtered]
     return gr.Dropdown(choices=choices, value=choices[0] if choices else None)
 
-def search_templates(search_query: str) -> gr.Dropdown:
-    if not search_query.strip():
-        choices: List[str] = [f"{t['name']} - {t.get('desc', '')[:50]}..." for t in motion.templates]
+def search_templates(q: str) -> gr.Dropdown:
+    if not q.strip():
+        choices = template_choices()
     else:
-        filtered: List[Dict[str, Any]] = motion.search_templates(search_query)
+        filtered = motion.search(q)
         choices = [f"{t['name']} - {t.get('desc', '')[:50]}..." for t in filtered]
     
     return gr.Dropdown(choices=choices, value=choices[0] if choices else None)
 
-def create_motion_video(input_files: Optional[List[Any]], aspect: str, output_format: str, 
-                       use_random: bool, selected_template: Optional[str], 
-                       progress: gr.Progress = gr.Progress()) -> Tuple[Optional[str], str, gr.DownloadButton]:
+def create_video(input_files: Optional[List[Any]], aspect: str, fmt: str, 
+                use_random: bool, selected: Optional[str], quality: str,
+                progress: gr.Progress = gr.Progress()) -> Tuple[Optional[str], str, gr.DownloadButton]:
+    
     def progress_fn(val: float, desc: str) -> None:
         progress(val, desc=desc)
     
     if not input_files:
         return None, "❌ No files provided", gr.DownloadButton(visible=False)
     
-    # Prepare template
-    template: Optional[Dict[str, Any]] = 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)
+    # Template
+    template = None
+    if not use_random and selected:
+        name = selected.split(" - ")[0]
+        template = next((t for t in motion.templates if t['name'] == name), None)
     
-    try:
-        result, status = processor.create_video(
-            input_files, aspect, output_format, progress_fn, template
-        )
-        
-        if result:
-            return result, f"✅ {status}", gr.DownloadButton(label="📥 Download Video", value=result, visible=True)
-        return None, f"❌ {status}", gr.DownloadButton(visible=False)
-    except Exception as e:
-        return None, f"❌ Error: {str(e)}", gr.DownloadButton(visible=False)
+    result, status = processor.create(input_files, aspect, fmt, progress_fn, template, quality)
+    
+    if result:
+        return result, f"✅ {status}", gr.DownloadButton(label="📥 Download", value=result, visible=True)
+    return None, f"❌ {status}", gr.DownloadButton(visible=False)
 
-def load_template(template_choice: Optional[str]) -> Tuple[str, int, float, float, float, float, float, float, str, str, float, float]:
-    if not template_choice:
+def load_template(choice: Optional[str]) -> Tuple:
+    if not 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])
+    name = choice.split(" - ")[0]
+    t = next((t for t in motion.templates if t['name'] == name), motion.templates[0])
     
     return (
-        template['name'], 
-        template['duration'],
-        template['scale'][0], template['scale'][1],
-        template['pan'][0], template['pan'][1],
-        template['pan'][2], template['pan'][3],
-        ', '.join(template.get('tags', [])),
-        template.get('desc', ''),
-        template['rotate'][0], template['rotate'][1]
+        t['name'], t['duration'],
+        t['scale'][0], t['scale'][1],
+        t['pan'][0], t['pan'][1], t['pan'][2], t['pan'][3],
+        ', '.join(t.get('tags', [])),
+        t.get('desc', ''),
+        t['rotate'][0], t['rotate'][1]
     )
 
-def save_template(name: str, duration: int, scale_start: float, scale_end: float, 
-                 x1: float, y1: float, x2: float, y2: float, tags: str, desc: str, 
-                 rot_start: float, rot_end: float) -> Tuple[str, gr.Dropdown]:
+def save_template(name: str, dur: int, s1: float, s2: float, 
+                 x1: float, y1: float, x2: float, y2: float, 
+                 tags: str, desc: str, r1: float, r2: float) -> Tuple[str, gr.Dropdown]:
     if not name:
-        return "❌ Enter template name", gr.Dropdown()
+        return "❌ Enter name", gr.Dropdown()
     
-    tag_list: List[str] = [tag.strip() for tag in tags.split(',') if tag.strip()] if tags else []
+    tag_list = [tag.strip() for tag in tags.split(',') if tag.strip()] if tags else []
     
-    new_template: Dict[str, Any] = {
-        '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}"
+    template = {
+        'name': name, 'duration': dur,
+        'scale': [s1, s2], 'pan': [x1, y1, x2, y2], 'rotate': [r1, r2],
+        'tags': tag_list, 'desc': desc or f"Custom: {name}"
     }
     
     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
+        motion.templates[existing] = template
     else:
-        motion.templates.append(new_template)
+        motion.templates.append(template)
     
-    motion.save_templates(motion.templates)
-    choices: List[str] = [f"{t['name']} - {t.get('desc', '')[:50]}..." for t in motion.templates]
+    motion.save(motion.templates)
+    choices = template_choices()
     return f"✅ Saved '{name}'!", gr.Dropdown(choices=choices, value=f"{name} - {desc[:50]}...")
 
-# Get all unique tags
-all_tags: set = set()
-for template in motion.templates:
-    all_tags.update(template.get('tags', []))
-tag_choices: List[str] = ["all"] + sorted(list(all_tags))
+# Tags
+all_tags = set()
+for t in motion.templates:
+    all_tags.update(t.get('tags', []))
+tag_choices = ["all"] + sorted(list(all_tags))
 
-# Interface
-with gr.Blocks(title="Ken Burns Story Creator", theme=gr.themes.Soft()) as app:
-    gr.Markdown("# 🎬 Ken Burns Story Creator", elem_classes="text-center")
-    gr.Markdown("Create motion videos for YouTube, TikTok, Reels with 35+ professional effects", elem_classes="text-center")
+# UI
+with gr.Blocks(title="Ken Burns Creator", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# 🎬 Ken Burns Story Creator")
+    gr.Markdown("Create motion videos for social media with 35+ effects")
     
     with gr.Tabs():
-        # Main tab - Create Video
-        with gr.Tab("📹 Create Video"):
+        with gr.Tab("📹 Create"):
             with gr.Row():
                 with gr.Column(scale=2):
-                    # File input
-                    gr.Markdown("### 📁 Upload Your Media")
+                    gr.Markdown("### 📁 Upload Media")
                     files_input = gr.File(
-                        label="Select Images/Videos", 
+                        label="Images/Videos", 
                         file_count="multiple",
-                        file_types=["image", "video"]
+                        file_types=["image", "video"],
+                        height=120
                     )
                     
-                    # Preview
                     with gr.Group():
-                        preview_img = gr.Image(label="📸 Preview", height=200, show_label=False)
-                        preview_info = gr.Textbox(label="Info", interactive=False, show_label=False)
+                        preview_img = gr.Image(label="Preview", height=150, show_label=False)
+                        preview_info = gr.Textbox(label="Info", interactive=False, lines=4, show_label=False)
                     
-                    # Motion settings
-                    gr.Markdown("### 🎭 Motion Effects")
+                    gr.Markdown("### 🎭 Effects")
                     with gr.Row():
-                        use_random = gr.Checkbox(label="🎲 Random Effects", value=True)
+                        use_random = gr.Checkbox(label="🎲 Random", value=True)
                         aspect_ratio = gr.Dropdown(
-                            choices=['reels', 'tiktok', 'youtube', 'square', 'widescreen'],
-                            value='reels',
-                            label="📱 Platform"
+                            choices=['reels', 'tiktok', 'youtube', 'square', 'wide'],
+                            value='reels', label="📱 Platform"
                         )
                     
-                    # Effect selector (hidden by default)
-                    with gr.Column(visible=False) as effect_selector:
+                    with gr.Column(visible=False) as effects:
                         with gr.Row():
-                            tag_filter = gr.Dropdown(
-                                choices=tag_choices, 
-                                value="all",
-                                label="🏷️ Filter by Tag"
-                            )
-                            search_box = gr.Textbox(
-                                label="🔍 Search", 
-                                placeholder="zoom, pan, dramatic..."
-                            )
+                            tag_filter = gr.Dropdown(choices=tag_choices, value="all", label="🏷️ Tag")
+                            search_box = gr.Textbox(label="🔍 Search", placeholder="zoom, pan...")
                         
                         template_dropdown = gr.Dropdown(
-                            choices=[f"{t['name']} - {t.get('desc', '')[:50]}..." for t in motion.templates],
-                            label="🎬 Select Effect",
-                            interactive=True
+                            choices=template_choices(), label="🎬 Effect"
                         )
                 
                 with gr.Column(scale=1):
-                    # Settings
                     gr.Markdown("### ⚙️ Settings")
-                    output_format = gr.Radio(
-                        choices=['mp4', 'gif'], 
-                        value='mp4', 
-                        label="📄 Output Format"
-                    )
                     
-                    # Create button
-                    create_btn = gr.Button(
-                        "🚀 Create Motion Video", 
-                        variant="primary", 
-                        size="lg",
-                        scale=2
-                    )
+                    with gr.Row():
+                        fmt = gr.Radio(['mp4', 'gif'], value='mp4', label="📄 Format")
+                        quality = gr.Dropdown([
+                            ('⚡ Fast', 'fast'), ('⚖️ Balanced', 'balanced'), 
+                            ('🎯 Quality', 'quality'), ('💎 Best', 'best')
+                        ], value='balanced', label="🎛️ Quality")
                     
-                    # Results
-                    status = gr.Textbox(label="📊 Status", interactive=False)
-                    output_video = gr.Video(label="🎥 Result", height=300)
-                    download_btn = gr.DownloadButton(
-                        label="📥 Download Video", 
-                        visible=False,
-                        variant="secondary"
-                    )
+                    create_btn = gr.Button("🚀 Create Video", 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)
         
-        # Templates tab
-        with gr.Tab("🎭 Motion Templates"):
-            gr.Markdown("### 🛠️ Template Editor")
-            gr.Markdown(f"**{len(motion.templates)} available templates** - Create and customize motion effects")
+        with gr.Tab("🎭 Templates"):
+            gr.Markdown(f"### Template Editor ({len(motion.templates)} available)")
             
             with gr.Row():
                 with gr.Column(scale=2):
-                    template_dropdown_edit = gr.Dropdown(
-                        choices=[f"{t['name']} - {t.get('desc', '')[:50]}..." for t in motion.templates],
-                        value=f"{motion.templates[0]['name']} - {motion.templates[0].get('desc', '')[:50]}..." if motion.templates else None,
-                        label="📋 Select Template to Edit"
+                    edit_dropdown = gr.Dropdown(
+                        choices=template_choices(),
+                        value=template_choices()[0] if motion.templates else None,
+                        label="Select Template"
                     )
                     
                     with gr.Row():
                         name_input = gr.Textbox(label="Name", placeholder="my_effect")
-                        duration_input = gr.Number(label="Duration (s)", value=4, minimum=2, maximum=10)
+                        dur_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)
+                        s1 = gr.Number(label="Scale Start", value=1.0, step=0.1)
+                        s2 = gr.Number(label="Scale End", value=1.3, step=0.1)
                     
                     with gr.Row():
                         x1 = gr.Number(label="Pan X1", value=0)
@@ -222,126 +206,68 @@ with gr.Blocks(title="Ken Burns Story Creator", theme=gr.themes.Soft()) as app:
                         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)
+                        r1 = gr.Number(label="Rotate Start", value=0)
+                        r2 = gr.Number(label="Rotate End", value=0)
                     
-                    tags_input = gr.Textbox(
-                        label="Tags (comma separated)", 
-                        placeholder="zoom, dramatic, smooth"
-                    )
-                    
-                    desc_input = gr.Textbox(
-                        label="Description",
-                        placeholder="Describe the motion effect...",
-                        lines=2
-                    )
+                    tags_input = gr.Textbox(label="Tags", placeholder="zoom, smooth, dramatic")
+                    desc_input = gr.Textbox(label="Description", lines=2)
                     
-                    save_btn = gr.Button("💾 Save Template", variant="primary")
-                    template_status = gr.Textbox(label="Status", interactive=False)
+                    save_btn = gr.Button("💾 Save", variant="primary")
+                    save_status = gr.Textbox(label="Status", interactive=False)
                 
                 with gr.Column(scale=1):
-                    gr.Markdown("### 📖 Quick Guide")
+                    gr.Markdown("### Guide")
                     gr.Markdown("""
-                    **Scale**: Zoom level
-                    - 1.0 = normal size
-                    - 1.3 = 30% bigger
-                    - 0.8 = 20% smaller
-                    
-                    **Pan**: Movement direction
-                    - X: left (-) / right (+)
-                    - Y: up (-) / down (+)
-                    
-                    **Rotate**: Angle in degrees
-                    - Positive = clockwise
-                    - Negative = counter-clockwise
-                    
-                    **Duration**: 3-7s optimal for social media
+                    **Scale**: 1.0=normal, 1.3=30% bigger
+                    **Pan**: X/Y movement (-=left/up, +=right/down)  
+                    **Rotate**: Degrees (+=clockwise)
+                    **Duration**: 3-7s optimal for social
                     """)
-                    
-                    gr.Markdown("### 🏷️ Popular Tags")
-                    gr.Markdown(", ".join(sorted(tag_choices[1:8])))  # Show first 7 tags
         
-        # Help tab
         with gr.Tab("ℹ️ Help"):
             gr.Markdown(f"""
-            ### 📖 How to Use
-            
-            1. **📁 Upload**: Select your images or videos
-            2. **📱 Platform**: Choose aspect ratio (Reels 9:16, YouTube 16:9, Square 1:1)
-            3. **🎭 Effects**: Use random or select specific motion templates
-            4. **🚀 Create**: Click the create button and wait
-            5. **📥 Download**: Get your final video
-            
-            ### 🎬 Motion Effects ({len(motion.templates)} total)
-            
-            **🔍 Zoom Effects**: Center, corners, dramatic, slow cinematic
-            **↔️ Pan Effects**: Horizontal, vertical, diagonal movements  
-            **🌀 Complex**: Zoom+pan, parallax, spiral, documentary style
-            **🎨 Special**: Breathing, pendulum, tilt, intimate close-ups
-            
-            ### 📱 Perfect for Social Media
-            
-            - **TikTok/Reels**: 9:16 vertical format
-            - **YouTube Shorts**: 16:9 or 9:16
-            - **Instagram Posts**: 1:1 square format
-            - **Stories**: Any format works
+            ### Quick Start
+            1. Upload images/videos
+            2. Choose platform (Reels=9:16, YouTube=16:9)  
+            3. Select random or specific effects
+            4. Create and download
             
-            ### ⚡ Performance Tips
+            ### {len(motion.templates)} Motion Effects
+            - **Zoom**: Center, corners, dramatic
+            - **Pan**: Horizontal, vertical, diagonal
+            - **Complex**: Parallax, spiral, documentary
+            - **Special**: Breathing, tilt, intimate
             
-            - Use high-resolution images (1080p+)
-            - Keep videos under 60 seconds for social media
-            - MP4 for quality, GIF for lightweight sharing
-            - Random effects create dynamic variety
-            
-            ### 🛠️ Technical
-            
-            - Processing: FFmpeg with Ken Burns effects
-            - Sequential processing for stability
-            - Optimized for 25 FPS output
-            - Quality preset: fast for speed
+            ### Tips
+            - Use 1080p+ images for best quality
+            - MP4 for quality, GIF for sharing
+            - 3-7s per image works well
+            - Mix effects for variety
             """)
     
-    # Event handlers
-    files_input.change(
-        fn=preview_files,
-        inputs=[files_input],
-        outputs=[preview_img, preview_info]
-    )
+    # Events
+    files_input.change(preview_files, [files_input], [preview_img, preview_info])
     
     create_btn.click(
-        fn=create_motion_video,
-        inputs=[files_input, aspect_ratio, output_format, use_random, template_dropdown],
-        outputs=[output_video, status, download_btn]
-    )
-    
-    use_random.change(
-        fn=lambda x: gr.update(visible=not x),
-        inputs=[use_random],
-        outputs=[effect_selector]
-    )
-    
-    tag_filter.change(
-        fn=filter_templates_by_tag, 
-        inputs=[tag_filter], 
-        outputs=[template_dropdown]
+        create_video,
+        [files_input, aspect_ratio, fmt, use_random, template_dropdown, quality],
+        [output_video, status, download_btn]
     )
     
-    search_box.change(
-        fn=search_templates, 
-        inputs=[search_box], 
-        outputs=[template_dropdown]
-    )
+    use_random.change(lambda x: gr.update(visible=not x), [use_random], [effects])
+    tag_filter.change(filter_by_tag, [tag_filter], [template_dropdown])
+    search_box.change(search_templates, [search_box], [template_dropdown])
     
-    template_dropdown_edit.change(
-        fn=load_template,
-        inputs=[template_dropdown_edit],
-        outputs=[name_input, duration_input, scale_start, scale_end, x1, y1, x2, y2, tags_input, desc_input, rot_start, rot_end]
+    edit_dropdown.change(
+        load_template, [edit_dropdown],
+        [name_input, dur_input, s1, s2, x1, y1, x2, y2, tags_input, desc_input, r1, r2]
     )
     
     save_btn.click(
-        fn=save_template,
-        inputs=[name_input, duration_input, scale_start, scale_end, x1, y1, x2, y2, tags_input, desc_input, rot_start, rot_end],
-        outputs=[template_status, template_dropdown_edit]
+        save_template,
+        [name_input, dur_input, s1, s2, x1, y1, x2, y2, tags_input, desc_input, r1, r2],
+        [save_status, edit_dropdown]
     )
 
-app.launch()
+if __name__ == "__main__":
+    app.launch()

src/file_handler.py

@@ -1,73 +1,141 @@
 import os
-import shutil
 from pathlib import Path
 from PIL import Image
-from typing import List, Optional, Set, Union, Any
+from typing import List, Optional, Union, Any, Dict, Tuple
+from .utils import IMG_EXTS, VID_EXTS, is_media, size_mb, unique_name
 
 class FileHandler:
-    IMG_EXTS: Set[str] = {'.jpg', '.jpeg', '.png', '.bmp', '.webp'}
-    VID_EXTS: Set[str] = {'.mp4', '.avi', '.mov', '.mkv'}
-    
     def __init__(self) -> None:
-        # Tạo temp trong thư mục hiện tại cho HuggingFace
-        self.temp_dir: str = os.path.join(os.getcwd(), 'tmp')
-        os.makedirs(self.temp_dir, exist_ok=True)
+        self.temp_dir = self._setup_temp()
+    
+    def _setup_temp(self) -> str:
+        temp = os.path.join(os.getcwd(), 'temp_processing')
+        os.makedirs(temp, exist_ok=True)
+        return temp
     
     def cleanup(self) -> None:
         if os.path.exists(self.temp_dir):
+            import shutil
             shutil.rmtree(self.temp_dir, ignore_errors=True)
     
-    def is_media(self, path: str) -> bool:
+    def info(self, path: str) -> Dict[str, Any]:
+        return {
+            'path': path,
+            'name': os.path.basename(path),
+            'size_mb': size_mb(path),
+            'type': self._type(path),
+            'dims': self._dims(path)
+        }
+    
+    def _type(self, path: str) -> str:
         ext = Path(path).suffix.lower()
-        return ext in self.IMG_EXTS or ext in self.VID_EXTS
+        if ext in IMG_EXTS:
+            return 'image'
+        elif ext in VID_EXTS:
+            return 'video'
+        return 'unknown'
+    
+    def _dims(self, path: str) -> Optional[str]:
+        if not os.path.exists(path):
+            return None
+            
+        if Path(path).suffix.lower() in IMG_EXTS:
+            with Image.open(path) as img:
+                return f"{img.width}x{img.height}"
+        return None
     
-    def get_files(self, folder_or_files: Union[str, List[Any], None]) -> List[str]:
-        """Get media files from folder or file list"""
-        if not folder_or_files:
+    def get_files(self, input: Union[str, List[Any], None]) -> List[str]:
+        if not input:
             return []
+        
+        if not isinstance(input, list):
+            input = [input]
             
-        if isinstance(folder_or_files, str) and os.path.isdir(folder_or_files):
-            return [str(p) for p in Path(folder_or_files).rglob('*') 
-                   if p.is_file() and self.is_media(str(p))]
+        # Handle folder
+        if (len(input) == 1 and 
+            isinstance(input[0], str) and 
+            os.path.isdir(input[0])):
+            return self._from_folder(input[0])
         
-        files = folder_or_files if isinstance(folder_or_files, list) else [folder_or_files]
-        result: List[str] = []
+        return self._extract_paths(input)
+    
+    def _from_folder(self, folder: str) -> List[str]:
+        return [str(p) for p in Path(folder).rglob('*') 
+                if p.is_file() and is_media(str(p))]
+    
+    def _extract_paths(self, files: List[Any]) -> List[str]:
+        result = []
         for f in files:
             if f is None:
                 continue
-            file_path = f.name if hasattr(f, 'name') else str(f)
-            if file_path and self.is_media(file_path):
-                result.append(file_path)
+                
+            path = None
+            if hasattr(f, 'name') and f.name:
+                path = f.name
+            elif hasattr(f, 'path') and f.path:
+                path = f.path
+            elif isinstance(f, str):
+                path = f
+                
+            if path and os.path.exists(path) and is_media(path):
+                result.append(path)
+                
         return result
     
-    def create_preview(self, files: List[str], max_items: int = 9) -> Optional[str]:
+    def preview(self, files: List[str], max_items: int = 6) -> Optional[str]:
         if not files:
             return None
         
-        images: List[Image.Image] = []
-        for f in files[:max_items]:
-            try:
-                if Path(f).suffix.lower() in self.IMG_EXTS:
-                    img = Image.open(f)
-                    img.thumbnail((150, 150))
-                    images.append(img)
-            except Exception:
-                continue
+        imgs = [f for f in files[:max_items] 
+               if os.path.exists(f) and Path(f).suffix.lower() in IMG_EXTS]
         
-        if not images:
+        if not imgs:
             return None
         
+        # Load and resize
+        images = []
+        for path in imgs:
+            with Image.open(path) as img:
+                copy = img.copy()
+                copy.thumbnail((120, 120))
+                images.append(copy)
+        
+        # Create grid
         cols = min(3, len(images))
         rows = (len(images) + cols - 1) // cols
-        grid = Image.new('RGB', (cols * 150, rows * 150), 'white')
+        grid = Image.new('RGB', (cols * 120, rows * 120), 'white')
         
         for i, img in enumerate(images):
-            x, y = (i % cols) * 150, (i // cols) * 150
+            x, y = (i % cols) * 120, (i // cols) * 120
             grid.paste(img, (x, y))
         
-        preview_path = os.path.join(self.temp_dir, f'preview_{os.getpid()}.jpg')
-        grid.save(preview_path)
-        return preview_path
+        path = os.path.join(self.temp_dir, unique_name('preview', '.jpg'))
+        grid.save(path, 'JPEG', quality=85)
+        return path
+    
+    def files_info(self, input: Union[str, List[Any], None]) -> Tuple[List[str], Dict[str, Any]]:
+        files = self.get_files(input)
+        
+        info = {
+            'total': len(files),
+            'size_mb': 0,
+            'images': 0,
+            'videos': 0,
+            'details': []
+        }
+        
+        for path in files:
+            detail = self.info(path)
+            info['details'].append(detail)
+            info['size_mb'] += detail['size_mb']
+            
+            if detail['type'] == 'image':
+                info['images'] += 1
+            elif detail['type'] == 'video':
+                info['videos'] += 1
+        
+        info['size_mb'] = round(info['size_mb'], 2)
+        return files, info
     
-    def temp_path(self, filename: str) -> str:
-        return os.path.join(self.temp_dir, filename)
+    def temp_path(self, name: str) -> str:
+        return os.path.join(self.temp_dir, name)

src/motion_processor.py

@@ -3,158 +3,194 @@ import random
 import subprocess
 import math
 import os
-from pathlib import Path
-from typing import List, Dict, Any, Optional, Tuple
+from typing import List, Dict, Any, Optional
+from .utils import ASPECTS, QUALITY, valid_template
 
 class MotionProcessor:
-    def __init__(self, motion_file: str = "motion.json") -> None:
-        self.motion_file: str = motion_file
-        self.templates: List[Dict[str, Any]] = self._load_templates()
-        self.aspect_ratios: Dict[str, str] = {
-            'youtube': '1920:1080',
-            'reels': '1080:1920',
-            'tiktok': '1080:1920',
-            'square': '1080:1080',
-            'widescreen': '1920:1080'
-        }
+    def __init__(self, file: str = "motion.json") -> None:
+        self.file = file
+        self.templates = self._load()
     
-    def _load_templates(self) -> List[Dict[str, Any]]:
-        try:
-            with open(self.motion_file, 'r', encoding='utf-8') as f:
-                return json.load(f)
-        except (FileNotFoundError, json.JSONDecodeError):
+    def _load(self) -> List[Dict[str, Any]]:
+        if not os.path.exists(self.file):
             return []
+        
+        with open(self.file, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        return [t for t in data if valid_template(t)]
     
-    def save_templates(self, templates: List[Dict[str, Any]]) -> None:
-        with open(self.motion_file, 'w', encoding='utf-8') as f:
-            json.dump(templates, f, indent=2, ensure_ascii=False)
-        self.templates = templates
+    def save(self, templates: List[Dict[str, Any]]) -> None:
+        valid = [t for t in templates if valid_template(t)]
+        
+        with open(self.file, 'w', encoding='utf-8') as f:
+            json.dump(valid, f, indent=2, ensure_ascii=False)
+        
+        self.templates = valid
     
-    def get_random_template(self) -> Dict[str, Any]:
+    def random(self) -> Dict[str, Any]:
         return random.choice(self.templates)
     
-    def get_templates_by_tag(self, tag: str) -> List[Dict[str, Any]]:
-        return [t for t in self.templates if tag.lower() in [tag.lower() for tag in t.get('tags', [])]]
+    def by_tag(self, tag: str) -> List[Dict[str, Any]]:
+        tag = tag.lower()
+        return [t for t in self.templates 
+                if tag in [t.lower() for t in t.get('tags', [])]]
     
-    def search_templates(self, query: str) -> List[Dict[str, Any]]:
-        query = query.lower()
+    def search(self, q: str) -> List[Dict[str, Any]]:
+        q = q.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', []))]
+                if q in t['name'].lower() or 
+                any(q in tag.lower() for tag in t.get('tags', []))]
     
-    def apply_motion(self, input_path: str, output_path: str, template: Optional[Dict[str, Any]] = None, 
-                    aspect: str = 'youtube') -> str:
-        if not template:
-            template = self.get_random_template()
+    def apply(self, input: str, output: str, 
+             template: Optional[Dict[str, Any]] = None,
+             aspect: str = 'youtube', 
+             quality: str = 'balanced') -> str:
         
-        resolution = self.aspect_ratios[aspect]
-        w, h = map(int, resolution.split(':'))
-        duration: int = template['duration']
-        fps: int = 25
+        t = template or self.random()
+        res = ASPECTS[aspect]
+        w, h = map(int, res.split(':'))
+        settings = QUALITY[quality]
         
         # Extract values
-        scale_start, scale_end = template['scale']
-        x1, y1, x2, y2 = template['pan']
-        rot_start, rot_end = template['rotate']
+        dur = t['duration']
+        s1, s2 = t['scale']
+        x1, y1, x2, y2 = t['pan']
+        r1, r2 = t['rotate']
         
-        total_frames: int = duration * fps
+        fps = 25
+        frames = dur * fps
         
-        # Tạo folder segments trong thư mục hiện tại
-        output_dir = os.path.dirname(output_path)
-        os.makedirs(output_dir, exist_ok=True)
+        os.makedirs(os.path.dirname(output), exist_ok=True)
         
-        # Simplified filter - tách riêng rotation nếu cần
-        if rot_start != rot_end and abs(rot_end - rot_start) > 0.1:
-            # Có rotation - xử lý riêng
-            temp_output = output_path.replace('.mp4', '_temp.mp4')
-            
-            # Bước 1: Zoom + Pan
-            zoompan_filter = (
-                f"[0:v]scale={w}:{h}:force_original_aspect_ratio=increase,"
-                f"crop={w}:{h},"
-                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}[v]"
-            )
-            
-            cmd1 = [
-                'ffmpeg', '-y', '-i', input_path,
-                '-filter_complex', zoompan_filter,
-                '-map', '[v]', '-t', str(duration),
-                '-c:v', 'libx264', '-preset', 'fast', '-crf', '23',
-                temp_output
-            ]
-            
-            # Bước 2: Rotation
-            rot_rad_start: float = math.radians(rot_start)
-            rot_rad_end: float = math.radians(rot_end)
-            rotate_filter = f"rotate='({rot_rad_start}+({rot_rad_end}-{rot_rad_start})*t/{duration})':c=black:ow={w}:oh={h}"
-            
-            cmd2 = [
-                'ffmpeg', '-y', '-i', temp_output,
-                '-vf', rotate_filter,
-                '-t', str(duration),
-                '-c:v', 'libx264', '-preset', 'fast', '-crf', '23',
-                output_path
-            ]
-            
-            subprocess.run(cmd1, check=True, capture_output=True)
-            subprocess.run(cmd2, check=True, capture_output=True)
-            
-            # Cleanup temp
-            if os.path.exists(temp_output):
-                os.unlink(temp_output)
-                
+        if self._has_rot(r1, r2):
+            return self._with_rotation(input, output, w, h, dur, fps, frames,
+                                     s1, s2, x1, y1, x2, y2, r1, r2, settings)
         else:
-            # Chỉ zoom + pan
-            filter_complex = (
-                f"[0:v]scale={w}:{h}:force_original_aspect_ratio=increase,"
-                f"crop={w}:{h},"
-                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}[v]"
-            )
-            
-            cmd = [
-                'ffmpeg', '-y', '-i', input_path,
-                '-filter_complex', filter_complex,
-                '-map', '[v]', '-t', str(duration),
-                '-c:v', 'libx264', '-preset', 'fast', '-crf', '23',
-                output_path
-            ]
-            
-            subprocess.run(cmd, check=True, capture_output=True)
+            return self._zoom_pan_only(input, output, w, h, dur, fps, frames,
+                                     s1, s2, x1, y1, x2, y2, settings)
+    
+    def _has_rot(self, r1: float, r2: float) -> bool:
+        return abs(r2 - r1) > 0.1
+    
+    def _zoom_pan_only(self, input: str, output: str, 
+                      w: int, h: int, dur: int, fps: int, frames: int,
+                      s1: float, s2: float, x1: float, y1: float, x2: float, y2: float,
+                      settings: Dict[str, str]) -> str:
         
-        return output_path
+        filter = (
+            f"[0:v]scale={w}:{h}:force_original_aspect_ratio=increase,"
+            f"crop={w}:{h},"
+            f"zoompan=z='min({s1}+({s2}-{s1})*on/{frames},{s2})':"
+            f"d={frames}:"
+            f"x='iw/2-(iw/zoom/2)+({x1}+({x2}-{x1})*on/{frames})':"
+            f"y='ih/2-(ih/zoom/2)+({y1}+({y2}-{y1})*on/{frames})':"
+            f"s={w}x{h}:fps={fps}[v]"
+        )
+        
+        cmd = [
+            'ffmpeg', '-y', '-i', input,
+            '-filter_complex', filter,
+            '-map', '[v]', '-t', str(dur),
+            '-c:v', 'libx264', '-preset', settings['preset'], '-crf', settings['crf'],
+            output
+        ]
+        
+        subprocess.run(cmd, check=True, capture_output=True)
+        return output
+    
+    def _with_rotation(self, input: str, output: str,
+                      w: int, h: int, dur: int, fps: int, frames: int,
+                      s1: float, s2: float, x1: float, y1: float, x2: float, y2: float,
+                      r1: float, r2: float, settings: Dict[str, str]) -> str:
+        
+        temp = output.replace('.mp4', '_temp.mp4')
+        
+        # Pass 1: Zoom + Pan
+        filter1 = (
+            f"[0:v]scale={w}:{h}:force_original_aspect_ratio=increase,"
+            f"crop={w}:{h},"
+            f"zoompan=z='min({s1}+({s2}-{s1})*on/{frames},{s2})':"
+            f"d={frames}:"
+            f"x='iw/2-(iw/zoom/2)+({x1}+({x2}-{x1})*on/{frames})':"
+            f"y='ih/2-(ih/zoom/2)+({y1}+({y2}-{y1})*on/{frames})':"
+            f"s={w}x{h}:fps={fps}[v]"
+        )
+        
+        cmd1 = [
+            'ffmpeg', '-y', '-i', input,
+            '-filter_complex', filter1,
+            '-map', '[v]', '-t', str(dur),
+            '-c:v', 'libx264', '-preset', settings['preset'], '-crf', settings['crf'],
+            temp
+        ]
+        
+        # Pass 2: Rotation
+        rad1, rad2 = math.radians(r1), math.radians(r2)
+        filter2 = f"rotate='({rad1}+({rad2}-{rad1})*t/{dur})':c=black:ow={w}:oh={h}"
+        
+        cmd2 = [
+            'ffmpeg', '-y', '-i', temp,
+            '-vf', filter2,
+            '-t', str(dur),
+            '-c:v', 'libx264', '-preset', settings['preset'], '-crf', settings['crf'],
+            output
+        ]
+        
+        subprocess.run(cmd1, check=True, capture_output=True)
+        subprocess.run(cmd2, check=True, capture_output=True)
+        
+        if os.path.exists(temp):
+            os.unlink(temp)
+            
+        return output
     
-    def concat_videos(self, video_files: List[str], output_path: str, output_format: str = 'mp4') -> str:
-        # Tạo list file trong thư mục hiện tại
-        list_file = os.path.join(os.getcwd(), f"temp_list_{os.getpid()}.txt")
+    def concat(self, files: List[str], output: str, fmt: str = 'mp4') -> str:
+        if not files:
+            raise ValueError("No files to concat")
+        
+        valid = [f for f in files if os.path.exists(f)]
+        if not valid:
+            raise ValueError("No valid files")
+        
+        from .utils import unique_name
+        list_file = unique_name("list", ".txt")
         
         with open(list_file, 'w', encoding='utf-8') as f:
-            for v in video_files:
-                # Escape paths cho Windows/Linux compatibility
-                escaped_path = v.replace('\\', '/')
-                f.write(f"file '{escaped_path}'\n")
+            for vid in valid:
+                path = os.path.abspath(vid).replace('\\', '/')
+                f.write(f"file '{path}'\n")
         
         try:
-            if output_format == 'gif':
-                subprocess.run([
+            if fmt == 'gif':
+                cmd = [
                     'ffmpeg', '-y', '-f', 'concat', '-safe', '0', '-i', list_file,
-                    '-vf', 'fps=12,scale=640:-1:flags=lanczos', output_path
-                ], check=True, capture_output=True)
+                    '-vf', 'fps=12,scale=640:-1:flags=lanczos',
+                    '-loop', '0', output
+                ]
             else:
-                subprocess.run([
+                cmd = [
                     'ffmpeg', '-y', '-f', 'concat', '-safe', '0', '-i', list_file,
-                    '-c', 'copy', output_path
-                ], check=True, capture_output=True)
+                    '-c', 'copy', output
+                ]
+                
+                try:
+                    subprocess.run(cmd, check=True, capture_output=True)
+                except subprocess.CalledProcessError:
+                    # Re-encode if copy fails
+                    cmd = [
+                        'ffmpeg', '-y', '-f', 'concat', '-safe', '0', '-i', list_file,
+                        '-c:v', 'libx264', '-preset', 'fast', '-crf', '23',
+                        '-c:a', 'aac', '-b:a', '128k', output
+                    ]
+            
+            subprocess.run(cmd, check=True, capture_output=True)
+            
         finally:
-            # Cleanup
             if os.path.exists(list_file):
                 os.unlink(list_file)
         
-        return output_path
+        if not os.path.exists(output):
+            raise RuntimeError("Output not created")
+        
+        return output

src/utils.py

@@ -0,0 +1,148 @@
+"""
+Common utilities and constants
+Stable functions that rarely change
+"""
+
+import os
+import time
+from pathlib import Path
+from typing import Dict, Any, List, Set
+
+# Constants
+SUPPORTED_IMAGE_EXTS: Set[str] = {'.jpg', '.jpeg', '.png', '.bmp', '.webp'}
+SUPPORTED_VIDEO_EXTS: Set[str] = {'.mp4', '.avi', '.mov', '.mkv'}
+
+ASPECT_RATIOS: Dict[str, str] = {
+    'youtube': '1920:1080',
+    'reels': '1080:1920', 
+    'tiktok': '1080:1920',
+    'square': '1080:1080',
+    'widescreen': '1920:1080'
+}
+
+QUALITY_PRESETS: Dict[str, Dict[str, str]] = {
+    'fast': {'preset': 'ultrafast', 'crf': '28'},
+    'balanced': {'preset': 'fast', 'crf': '23'},
+    'quality': {'preset': 'medium', 'crf': '20'}, 
+    'best': {'preset': 'slow', 'crf': '18'}
+}
+
+# Utility functions
+def is_image(file_path: str) -> bool:
+    """Check if file is supported image format"""
+    return Path(file_path).suffix.lower() in SUPPORTED_IMAGE_EXTS
+
+def is_video(file_path: str) -> bool:
+    """Check if file is supported video format"""
+    return Path(file_path).suffix.lower() in SUPPORTED_VIDEO_EXTS
+
+def is_media(file_path: str) -> bool:
+    """Check if file is supported media format"""
+    return is_image(file_path) or is_video(file_path)
+
+def get_file_size_mb(file_path: str) -> float:
+    """Get file size in MB"""
+    if not os.path.exists(file_path):
+        return 0.0
+    return round(os.path.getsize(file_path) / (1024 * 1024), 2)
+
+def unique_filename(prefix: str, extension: str = '.mp4') -> str:
+    """Generate unique filename with timestamp and PID"""
+    return f"{prefix}_{int(time.time())}_{os.getpid()}{extension}"
+
+def safe_filename(name: str) -> str:
+    """Make filename safe for filesystem"""
+    invalid_chars = '<>:"/\\|?*'
+    for char in invalid_chars:
+        name = name.replace(char, '_')
+    return name[:100]  # Limit length
+
+def format_duration(seconds: int) -> str:
+    """Format seconds to human readable duration"""
+    if seconds < 60:
+        return f"{seconds}s"
+    elif seconds < 3600:
+        return f"{seconds // 60}m {seconds % 60}s"
+    else:
+        h = seconds // 3600
+        m = (seconds % 3600) // 60
+        return f"{h}h {m}m"
+
+def estimate_output_size(input_files: List[str], duration_per_file: int = 4) -> Dict[str, Any]:
+    """Estimate output video characteristics"""
+    total_files = len(input_files)
+    total_duration = total_files * duration_per_file
+    
+    # Rough size estimation (varies greatly by content)
+    estimated_size_mb = total_duration * 2  # ~2MB per second for balanced quality
+    
+    return {
+        'files': total_files,
+        'duration': total_duration,
+        'duration_formatted': format_duration(total_duration),
+        'estimated_size_mb': round(estimated_size_mb, 1)
+    }
+
+def validate_template(template: Dict[str, Any]) -> bool:
+    """Validate motion template structure"""
+    required_fields = ['name', 'scale', 'pan', 'rotate', 'duration']
+    
+    if not all(field in template for field in required_fields):
+        return False
+    
+    # Validate data types and ranges
+    if not isinstance(template['duration'], (int, float)) or template['duration'] <= 0:
+        return False
+        
+    if not (isinstance(template['scale'], list) and len(template['scale']) == 2):
+        return False
+        
+    if not (isinstance(template['pan'], list) and len(template['pan']) == 4):
+        return False
+        
+    if not (isinstance(template['rotate'], list) and len(template['rotate']) == 2):
+        return False
+    
+    return True
+
+def get_platform_info(aspect_key: str) -> Dict[str, str]:
+    """Get platform information and recommendations"""
+    platform_info = {
+        'youtube': {
+            'name': 'YouTube',
+            'ratio': '16:9',
+            'optimal_duration': '15-60s',
+            'description': 'Horizontal format for YouTube Shorts and regular videos'
+        },
+        'reels': {
+            'name': 'Instagram Reels',
+            'ratio': '9:16', 
+            'optimal_duration': '15-30s',
+            'description': 'Vertical format optimized for mobile viewing'
+        },
+        'tiktok': {
+            'name': 'TikTok',
+            'ratio': '9:16',
+            'optimal_duration': '15-60s', 
+            'description': 'Vertical format for TikTok content'
+        },
+        'square': {
+            'name': 'Instagram Post',
+            'ratio': '1:1',
+            'optimal_duration': '15-30s',
+            'description': 'Square format for Instagram feed posts'
+        },
+        'widescreen': {
+            'name': 'Widescreen',
+            'ratio': '16:9',
+            'optimal_duration': '30-120s',
+            'description': 'Standard widescreen format for presentations'
+        }
+    }
+    
+    return platform_info.get(aspect_key, {
+        'name': 'Custom',
+        'ratio': 'Custom',
+        'optimal_duration': 'Variable',
+        'description': 'Custom aspect ratio'
+    })

src/video_processor.py

@@ -1,85 +1,103 @@
 import os
 import shutil
-from pathlib import Path
 from typing import List, Tuple, Optional, Dict, Any, Callable
-
-# Import custom classes
 from .motion_processor import MotionProcessor
 from .file_handler import FileHandler
+from .utils import unique_name, size_mb
 
 class VideoProcessor:
-    def __init__(self, motion_processor: MotionProcessor, file_handler: FileHandler) -> None:
-        self.motion: MotionProcessor = motion_processor
-        self.files: FileHandler = file_handler
+    def __init__(self, motion: MotionProcessor, files: FileHandler) -> None:
+        self.motion = motion
+        self.files = files
     
-    def process_single(self, file_path: str, output_path: str, aspect: str, 
-                      template: Optional[Dict[str, Any]] = None) -> Optional[str]:
-        try:
-            return self.motion.apply_motion(file_path, output_path, template, aspect)
-        except Exception as e:
-            print(f"Error processing {file_path}: {e}")
-            return None
+    def process_one(self, input: str, output: str, aspect: str, 
+                   template: Optional[Dict[str, Any]] = None, 
+                   quality: str = 'balanced') -> str:
+        return self.motion.apply(input, output, template, aspect, quality)
     
-    def create_video(self, input_files: List[Any], aspect: str = 'youtube', 
-                    output_format: str = 'mp4', progress_fn: Optional[Callable[[float, str], None]] = None, 
-                    selected_template: Optional[Dict[str, Any]] = None) -> Tuple[Optional[str], str]:
-        files: List[str] = self.files.get_files(input_files)
+    def create(self, input_files: List[Any], aspect: str = 'youtube', 
+              fmt: str = 'mp4', 
+              progress: Optional[Callable[[float, str], None]] = None, 
+              template: Optional[Dict[str, Any]] = None,
+              quality: str = 'balanced') -> Tuple[Optional[str], str]:
+        
+        # Get files
+        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 trong thư mục hiện tại
-        segments_dir: str = os.path.join(os.getcwd(), f"segments_{os.getpid()}")
-        os.makedirs(segments_dir, exist_ok=True)
-
-        processed: List[str] = []
+        # Setup
+        seg_dir = self._setup_segments()
+        processed = []
+        
+        if progress:
+            progress(0.1, f"Processing {len(files)} files with {quality} quality...")
         
         try:
-            # Xử lý tuần tự để tránh lỗi parallel trên HuggingFace
-            for i, file_path in enumerate(files):
-                output_path: str = os.path.join(segments_dir, f"seg_{i:03d}.mp4")
-                
-                try:
-                    result: Optional[str] = self.process_single(file_path, output_path, aspect, selected_template)
-                    if result:
-                        processed.append(result)
-                        if progress_fn:
-                            progress_fn(0.1 + 0.6 * (i + 1) / len(files), f"Processed {i+1}/{len(files)} files")
-                except Exception as e:
-                    print(f"Error processing {file_path}: {e}")
-                    continue
-
+            # Process each file
+            processed = self._process_all(files, seg_dir, aspect, template, quality, progress)
+            
             if not processed:
-                return None, "Failed to process any files"
-
-            if progress_fn:
-                progress_fn(0.8, "Combining segments...")
-
-            # Combine videos
-            ext: str = 'gif' if output_format == 'gif' else 'mp4'
-            final_output: str = os.path.join(os.getcwd(), f"final_output_{os.getpid()}.{ext}")
-
-            self.motion.concat_videos(processed, final_output, output_format)
-
-            if progress_fn:
-                progress_fn(1.0, "Complete!")
-
-            return final_output, f"Created video from {len(files)} files"
+                raise RuntimeError("Failed to process any files")
+            
+            # Combine
+            final = self._combine(processed, fmt, progress)
+            
+            # Info
+            out_size = size_mb(final)
+            
+            if progress:
+                progress(1.0, "Complete!")
+            
+            return final, f"Created {fmt.upper()} from {len(processed)} segments ({out_size} MB)"
             
         finally:
-            # Cleanup segments
-            for seg in processed:
-                try:
-                    if os.path.exists(seg):
-                        os.unlink(seg)
-                except Exception:
-                    pass
+            self._cleanup(processed, seg_dir)
+    
+    def _setup_segments(self) -> str:
+        seg_dir = os.path.join(os.getcwd(), unique_name("segments", ""))
+        os.makedirs(seg_dir, exist_ok=True)
+        return seg_dir
+    
+    def _process_all(self, files: List[str], seg_dir: str, aspect: str,
+                    template: Optional[Dict[str, Any]], quality: str,
+                    progress: Optional[Callable[[float, str], None]]) -> List[str]:
+        processed = []
+        
+        for i, path in enumerate(files):
+            output = os.path.join(seg_dir, f"seg_{i:03d}.mp4")
             
-            # Cleanup segments directory
-            try:
-                if os.path.exists(segments_dir):
-                    shutil.rmtree(segments_dir)
-            except Exception:
-                pass
+            result = self.process_one(path, output, aspect, template, quality)
+            
+            if not os.path.exists(result):
+                raise RuntimeError(f"Failed to process {path}")
+            
+            processed.append(result)
+            
+            if progress:
+                progress(0.1 + 0.6 * (i + 1) / len(files), f"Processed {i+1}/{len(files)} files")
+        
+        return processed
+    
+    def _combine(self, processed: List[str], fmt: str,
+                progress: Optional[Callable[[float, str], None]]) -> str:
+        if progress:
+            progress(0.8, f"Combining {len(processed)} segments...")
+        
+        ext = 'gif' if fmt == 'gif' else 'mp4'
+        final = os.path.join(os.getcwd(), unique_name("final", f".{ext}"))
+        
+        self.motion.concat(processed, final, fmt)
+        
+        if not os.path.exists(final):
+            raise RuntimeError("Failed to create final output")
+        
+        return final
+    
+    def _cleanup(self, processed: List[str], seg_dir: str) -> None:
+        for seg in processed:
+            if os.path.exists(seg):
+                os.unlink(seg)
+        
+        if os.path.exists(seg_dir):
+            shutil.rmtree(seg_dir)