Delete gitea-push-mirror-setup.md

Implement standalone PyTorch-based RIFE interpolation that runs in a
dedicated virtual environment to avoid Qt/OpenCV conflicts:

- Add PracticalRifeEnv class for managing venv and subprocess execution
- Add rife_worker.py standalone interpolation script using Practical-RIFE
- Add RIFE_PRACTICAL blending model with ensemble/fast mode settings
- Add UI controls for Practical-RIFE configuration
- Update .gitignore to exclude venv-rife/ directory

The implementation downloads Practical-RIFE models on first use and runs
interpolation in a separate process with proper progress reporting.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

README.md

@@ -13,20 +13,18 @@ A PyQt6 application for creating sequenced symlinks from image folders with adva
 - Per-folder trim settings (exclude frames from start/end)
 
 ### Cross-Dissolve Transitions
-Smooth blending between folder boundaries with four blend methods:
+Smooth blending between folder boundaries with three blend methods:
 
 | Method | Description | Quality | Speed |
 |--------|-------------|---------|-------|
 | **Cross-Dissolve** | Simple alpha blend | Good | Fastest |
 | **Optical Flow** | Motion-compensated blend using OpenCV Farneback | Better | Medium |
-| **RIFE (ncnn)** | Neural network interpolation via rife-ncnn-vulkan | Best | Fast (GPU) |
-| **RIFE (Practical)** | PyTorch-based Practical-RIFE (v4.25/v4.26) | Best | Medium (GPU) |
+| **RIFE (AI)** | Neural network frame interpolation | Best | Fast (GPU) |
 
 - **Asymmetric overlap**: Set different frame counts for each side of a transition
 - **Blend curves**: Linear, Ease In, Ease Out, Ease In/Out
 - **Output formats**: PNG, JPEG (with quality), WebP (lossless with method setting)
 - **RIFE auto-download**: Automatically downloads rife-ncnn-vulkan binary
-- **Practical-RIFE models**: Auto-downloads from Google Drive on first use
 
 ### Preview
 - **Video Preview**: Play video files from source folders
@@ -56,24 +54,11 @@ Smooth blending between folder boundaries with four blend methods:
 pip install PyQt6 Pillow numpy opencv-python
 ```
 
-**Note:** Practical-RIFE creates its own isolated venv with PyTorch. The `gdown` package is installed automatically for downloading models from Google Drive.
-
-### RIFE ncnn (Optional)
-For AI-powered frame interpolation using Vulkan GPU acceleration:
-- Select **RIFE (ncnn)** as the blend method
-- Click **Download** to auto-fetch [rife-ncnn-vulkan](https://github.com/nihui/rife-ncnn-vulkan)
+### RIFE (Optional)
+For AI-powered frame interpolation, the app can auto-download [rife-ncnn-vulkan](https://github.com/nihui/rife-ncnn-vulkan) or you can install it manually:
+- Select **RIFE (AI)** as the blend method
+- Click **Download** to fetch the latest release
 - Or specify a custom binary path
-- Models: rife-v4.6, rife-v4.15-lite, etc.
-
-### Practical-RIFE (Optional)
-For PyTorch-based frame interpolation with latest models:
-- Select **RIFE (Practical)** as the blend method
-- Click **Setup PyTorch** to create an isolated venv with PyTorch (~2GB)
-- Models auto-download from Google Drive on first use
-- Available models: v4.26, v4.25, v4.22, v4.20, v4.18, v4.15
-- Optional ensemble mode for higher quality (slower)
-
-The venv is stored at `~/.cache/video-montage-linker/venv-rife/`
 
 ## Usage
 
@@ -113,8 +98,7 @@ video-montage-linker/
 ├── core/
 │   ├── models.py       # Enums, dataclasses
 │   ├── database.py     # SQLite session management
-│   ├── blender.py      # Image blending, RIFE downloader, Practical-RIFE env
-│   ├── rife_worker.py  # Practical-RIFE inference (runs in isolated venv)
+│   ├── blender.py      # Image blending, RIFE downloader
 │   └── manager.py      # Symlink operations
 └── ui/
     ├── widgets.py      # TrimSlider, custom widgets

core/__init__.py

@@ -4,12 +4,8 @@ from .models import (
     BlendCurve,
     BlendMethod,
     FolderType,
-    DirectInterpolationMethod,
     TransitionSettings,
     PerTransitionSettings,
-    DirectTransitionSettings,
-    VideoPreset,
-    VIDEO_PRESETS,
     BlendResult,
     TransitionSpec,
     LinkResult,
@@ -23,20 +19,15 @@ from .models import (
     DatabaseError,
 )
 from .database import DatabaseManager
-from .blender import ImageBlender, TransitionGenerator, RifeDownloader, PracticalRifeEnv, FilmEnv, BimVfiEnv, OPTICAL_FLOW_PRESETS
+from .blender import ImageBlender, TransitionGenerator, RifeDownloader, PracticalRifeEnv
 from .manager import SymlinkManager
-from .video import encode_image_sequence, encode_from_file_list, find_ffmpeg
 
 __all__ = [
     'BlendCurve',
     'BlendMethod',
     'FolderType',
-    'DirectInterpolationMethod',
     'TransitionSettings',
     'PerTransitionSettings',
-    'DirectTransitionSettings',
-    'VideoPreset',
-    'VIDEO_PRESETS',
     'BlendResult',
     'TransitionSpec',
     'LinkResult',
@@ -53,11 +44,5 @@ __all__ = [
     'TransitionGenerator',
     'RifeDownloader',
     'PracticalRifeEnv',
-    'FilmEnv',
-    'BimVfiEnv',
     'SymlinkManager',
-    'OPTICAL_FLOW_PRESETS',
-    'encode_image_sequence',
-    'encode_from_file_list',
-    'find_ffmpeg',
 ]

core/bim_vfi_worker.py

@@ -1,232 +0,0 @@
-#!/usr/bin/env python
-"""BiM-VFI interpolation worker - runs in isolated venv with PyTorch.
-
-This script is executed via subprocess from the main application.
-It handles frame interpolation using KAIST VICLab's BiM-VFI model
-(Bidirectional Motion Field-Guided Frame Interpolation).
-
-BiM-VFI is designed for non-uniform motions and produces high-quality
-results, especially for complex scenes (CVPR 2025).
-
-Supports two modes:
-1. Single frame: --output with --timestep
-2. Batch mode: --output-dir with --frame-count (generates all frames at once)
-"""
-
-import argparse
-import sys
-from pathlib import Path
-
-import numpy as np
-import torch
-from PIL import Image
-
-# Checkpoint filename
-BIM_VFI_CHECKPOINT = "bim_vfi.pth"
-
-
-def load_image(path: Path, device: torch.device) -> torch.Tensor:
-    """Load image as tensor.
-
-    Args:
-        path: Path to image file.
-        device: Device to load tensor to.
-
-    Returns:
-        Image tensor (1, 3, H, W) normalized to [0, 1].
-    """
-    img = Image.open(path).convert('RGB')
-    arr = np.array(img).astype(np.float32) / 255.0
-    tensor = torch.from_numpy(arr).permute(2, 0, 1).unsqueeze(0)
-    return tensor.to(device)
-
-
-def save_image(tensor: torch.Tensor, path: Path) -> None:
-    """Save tensor as image.
-
-    Args:
-        tensor: Image tensor (1, 3, H, W) or (3, H, W) normalized to [0, 1].
-        path: Output path.
-    """
-    if tensor.dim() == 4:
-        tensor = tensor.squeeze(0)
-    arr = tensor.permute(1, 2, 0).cpu().numpy()
-    arr = (arr * 255).clip(0, 255).astype(np.uint8)
-    Image.fromarray(arr).save(path)
-
-
-_model_cache: dict = {}
-
-
-def get_model(repo_dir: Path, model_dir: Path, device: torch.device):
-    """Get or load BiM-VFI model (cached).
-
-    Args:
-        repo_dir: Path to the cloned BiM-VFI repository.
-        model_dir: Directory containing the checkpoint.
-        device: Device to run on.
-
-    Returns:
-        BiM-VFI model instance.
-    """
-    cache_key = f"bim_vfi_{device}"
-    if cache_key not in _model_cache:
-        # Add repo to sys.path so we can import BiM-VFI modules
-        repo_str = str(repo_dir)
-        if repo_str not in sys.path:
-            sys.path.insert(0, repo_str)
-
-        checkpoint_path = model_dir / BIM_VFI_CHECKPOINT
-
-        if not checkpoint_path.exists():
-            raise FileNotFoundError(
-                f"BiM-VFI checkpoint not found at {checkpoint_path}. "
-                "Please download it from Google Drive and place it there."
-            )
-
-        print(f"Loading BiM-VFI model from {checkpoint_path}...", file=sys.stderr)
-
-        # Import from the package __init__ so the @register decorator fires
-        from modules.components import make_components
-
-        # Create model with the trained config (pyr_level=3, feat_channels=32)
-        cfg = {'name': 'bim_vfi', 'args': {'pyr_level': 3, 'feat_channels': 32}}
-        model = make_components(cfg)
-
-        # Load checkpoint
-        ckpt = torch.load(str(checkpoint_path), map_location='cpu', weights_only=False)
-        model.load_state_dict(ckpt['model'])
-
-        model.eval()
-        model.to(device)
-        _model_cache[cache_key] = model
-        print("Model loaded.", file=sys.stderr)
-
-    return _model_cache[cache_key]
-
-
-@torch.no_grad()
-def interpolate_single(
-    model, img0: torch.Tensor, img1: torch.Tensor, t: float
-) -> torch.Tensor:
-    """Perform single frame interpolation using BiM-VFI.
-
-    Uses the model's trained pyr_level (set at construction time).
-    The model handles input padding internally via InputPadder.
-
-    Args:
-        model: BiM-VFI model instance.
-        img0: First frame tensor (1, 3, H, W) normalized to [0, 1].
-        img1: Second frame tensor (1, 3, H, W) normalized to [0, 1].
-        t: Interpolation timestep (0.0 to 1.0).
-
-    Returns:
-        Interpolated frame tensor.
-    """
-    time_step = torch.tensor([t]).view(1, 1, 1, 1).to(img0.device)
-
-    results_dict = model(
-        img0=img0, img1=img1,
-        time_step=time_step,
-    )
-
-    return results_dict['imgt_pred'].clamp(0, 1)
-
-
-@torch.no_grad()
-def interpolate_batch(
-    model, img0: torch.Tensor, img1: torch.Tensor, frame_count: int
-) -> list[torch.Tensor]:
-    """Generate multiple interpolated frames using BiM-VFI.
-
-    Args:
-        model: BiM-VFI model instance.
-        img0: First frame tensor (1, 3, H, W) normalized to [0, 1].
-        img1: Second frame tensor (1, 3, H, W) normalized to [0, 1].
-        frame_count: Number of frames to generate between img0 and img1.
-
-    Returns:
-        List of interpolated frame tensors in order.
-    """
-    frames = []
-    for i in range(frame_count):
-        t = (i + 1) / (frame_count + 1)
-        frame = interpolate_single(model, img0, img1, t)
-        frames.append(frame)
-    return frames
-
-
-def main():
-    parser = argparse.ArgumentParser(description='BiM-VFI frame interpolation worker')
-    parser.add_argument('--input0', required=True, help='Path to first input image')
-    parser.add_argument('--input1', required=True, help='Path to second input image')
-    parser.add_argument('--output', help='Path to output image (single frame mode)')
-    parser.add_argument('--output-dir', help='Output directory (batch mode)')
-    parser.add_argument('--output-pattern', default='frame_{:04d}.png',
-                        help='Output filename pattern for batch mode')
-    parser.add_argument('--timestep', type=float, default=0.5,
-                        help='Interpolation timestep 0-1 (single frame mode)')
-    parser.add_argument('--frame-count', type=int,
-                        help='Number of frames to generate (batch mode)')
-    parser.add_argument('--repo-dir', required=True, help='Path to BiM-VFI repo clone')
-    parser.add_argument('--model-dir', required=True, help='Model cache directory')
-    parser.add_argument('--device', default='cuda', choices=['cuda', 'cpu'], help='Device to use')
-
-    args = parser.parse_args()
-
-    # Validate arguments
-    batch_mode = args.output_dir is not None and args.frame_count is not None
-    single_mode = args.output is not None
-
-    if not batch_mode and not single_mode:
-        print("Error: Must specify either --output (single) or --output-dir + --frame-count (batch)",
-              file=sys.stderr)
-        return 1
-
-    try:
-        # Select device
-        if args.device == 'cuda' and torch.cuda.is_available():
-            device = torch.device('cuda')
-        else:
-            device = torch.device('cpu')
-
-        # Load model
-        repo_dir = Path(args.repo_dir)
-        model_dir = Path(args.model_dir)
-        model = get_model(repo_dir, model_dir, device)
-
-        # Load images
-        img0 = load_image(Path(args.input0), device)
-        img1 = load_image(Path(args.input1), device)
-
-        if batch_mode:
-            # Batch mode - generate all frames at once
-            output_dir = Path(args.output_dir)
-            output_dir.mkdir(parents=True, exist_ok=True)
-
-            print(f"Generating {args.frame_count} frames...", file=sys.stderr)
-            frames = interpolate_batch(model, img0, img1, args.frame_count)
-
-            for i, frame in enumerate(frames):
-                output_path = output_dir / args.output_pattern.format(i)
-                save_image(frame, output_path)
-                print(f"Saved {output_path.name}", file=sys.stderr)
-
-            print(f"Success: Generated {len(frames)} frames", file=sys.stderr)
-        else:
-            # Single frame mode
-            result = interpolate_single(model, img0, img1, args.timestep)
-            save_image(result, Path(args.output))
-            print("Success", file=sys.stderr)
-
-        return 0
-
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-        import traceback
-        traceback.print_exc(file=sys.stderr)
-        return 1
-
-
-if __name__ == '__main__':
-    sys.exit(main())

core/database.py

@@ -39,8 +39,7 @@ class DatabaseManager:
                 CREATE TABLE IF NOT EXISTS symlink_sessions (
                     id INTEGER PRIMARY KEY,
                     created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                    destination TEXT NOT NULL,
-                    name TEXT DEFAULT NULL
+                    destination TEXT NOT NULL
                 );
 
                 CREATE TABLE IF NOT EXISTS symlinks (
@@ -83,24 +82,6 @@ class DatabaseManager:
                     right_overlap INTEGER DEFAULT 16,
                     UNIQUE(session_id, trans_folder)
                 );
-
-                CREATE TABLE IF NOT EXISTS removed_files (
-                    id INTEGER PRIMARY KEY,
-                    session_id INTEGER REFERENCES symlink_sessions(id) ON DELETE CASCADE,
-                    source_folder TEXT NOT NULL,
-                    filename TEXT NOT NULL,
-                    UNIQUE(session_id, source_folder, filename)
-                );
-
-                CREATE TABLE IF NOT EXISTS direct_transition_settings (
-                    id INTEGER PRIMARY KEY,
-                    session_id INTEGER REFERENCES symlink_sessions(id) ON DELETE CASCADE,
-                    after_folder TEXT NOT NULL,
-                    frame_count INTEGER DEFAULT 16,
-                    method TEXT DEFAULT 'film',
-                    enabled INTEGER DEFAULT 1,
-                    UNIQUE(session_id, after_folder)
-                );
             """)
 
             # Migration: add folder_type column if it doesn't exist
@@ -133,168 +114,20 @@ class DatabaseManager:
             except sqlite3.OperationalError:
                 conn.execute("ALTER TABLE transition_settings ADD COLUMN rife_binary_path TEXT")
 
-            # Migration: add folder_order column if it doesn't exist
-            try:
-                conn.execute("SELECT folder_order FROM sequence_trim_settings LIMIT 1")
-            except sqlite3.OperationalError:
-                conn.execute("ALTER TABLE sequence_trim_settings ADD COLUMN folder_order INTEGER DEFAULT 0")
-
-            # Migration: add name column to symlink_sessions if it doesn't exist
-            try:
-                conn.execute("SELECT name FROM symlink_sessions LIMIT 1")
-            except sqlite3.OperationalError:
-                conn.execute("ALTER TABLE symlink_sessions ADD COLUMN name TEXT DEFAULT NULL")
-
-            # Migration: widen UNIQUE constraints to allow duplicate folder paths per session.
-            # sequence_trim_settings: UNIQUE(session_id, source_folder) → UNIQUE(session_id, folder_order)
-            self._migrate_unique_constraint(
-                conn, 'sequence_trim_settings',
-                """CREATE TABLE sequence_trim_settings_new (
-                    id INTEGER PRIMARY KEY,
-                    session_id INTEGER REFERENCES symlink_sessions(id) ON DELETE CASCADE,
-                    source_folder TEXT NOT NULL,
-                    trim_start INTEGER DEFAULT 0,
-                    trim_end INTEGER DEFAULT 0,
-                    folder_type TEXT DEFAULT 'auto',
-                    folder_order INTEGER DEFAULT 0,
-                    UNIQUE(session_id, folder_order)
-                )""",
-                'session_id, source_folder, trim_start, trim_end, folder_type, folder_order',
-            )
-
-            # per_transition_settings: add folder_order, widen UNIQUE
-            try:
-                conn.execute("SELECT folder_order FROM per_transition_settings LIMIT 1")
-            except sqlite3.OperationalError:
-                conn.execute("ALTER TABLE per_transition_settings ADD COLUMN folder_order INTEGER DEFAULT 0")
-            self._migrate_unique_constraint(
-                conn, 'per_transition_settings',
-                """CREATE TABLE per_transition_settings_new (
-                    id INTEGER PRIMARY KEY,
-                    session_id INTEGER REFERENCES symlink_sessions(id) ON DELETE CASCADE,
-                    trans_folder TEXT NOT NULL,
-                    left_overlap INTEGER DEFAULT 16,
-                    right_overlap INTEGER DEFAULT 16,
-                    folder_order INTEGER DEFAULT 0,
-                    UNIQUE(session_id, trans_folder, folder_order)
-                )""",
-                'session_id, trans_folder, left_overlap, right_overlap, folder_order',
-            )
-
-            # removed_files: add folder_order, widen UNIQUE
-            try:
-                conn.execute("SELECT folder_order FROM removed_files LIMIT 1")
-            except sqlite3.OperationalError:
-                conn.execute("ALTER TABLE removed_files ADD COLUMN folder_order INTEGER DEFAULT 0")
-            self._migrate_unique_constraint(
-                conn, 'removed_files',
-                """CREATE TABLE removed_files_new (
-                    id INTEGER PRIMARY KEY,
-                    session_id INTEGER REFERENCES symlink_sessions(id) ON DELETE CASCADE,
-                    source_folder TEXT NOT NULL,
-                    filename TEXT NOT NULL,
-                    folder_order INTEGER DEFAULT 0,
-                    UNIQUE(session_id, source_folder, filename, folder_order)
-                )""",
-                'session_id, source_folder, filename, folder_order',
-            )
-
-            # direct_transition_settings: add folder_order, widen UNIQUE
-            try:
-                conn.execute("SELECT folder_order FROM direct_transition_settings LIMIT 1")
-            except sqlite3.OperationalError:
-                conn.execute("ALTER TABLE direct_transition_settings ADD COLUMN folder_order INTEGER DEFAULT 0")
-            self._migrate_unique_constraint(
-                conn, 'direct_transition_settings',
-                """CREATE TABLE direct_transition_settings_new (
-                    id INTEGER PRIMARY KEY,
-                    session_id INTEGER REFERENCES symlink_sessions(id) ON DELETE CASCADE,
-                    after_folder TEXT NOT NULL,
-                    frame_count INTEGER DEFAULT 16,
-                    method TEXT DEFAULT 'film',
-                    enabled INTEGER DEFAULT 1,
-                    folder_order INTEGER DEFAULT 0,
-                    UNIQUE(session_id, after_folder, folder_order)
-                )""",
-                'session_id, after_folder, frame_count, method, enabled, folder_order',
-            )
-
-            # Migration: add locked column to symlink_sessions
-            try:
-                conn.execute("SELECT locked FROM symlink_sessions LIMIT 1")
-            except sqlite3.OperationalError:
-                conn.execute("ALTER TABLE symlink_sessions ADD COLUMN locked INTEGER DEFAULT 0")
-
             # Migration: remove overlap_frames from transition_settings (now per-transition)
             # We'll keep it for backward compatibility but won't use it
 
-    @staticmethod
-    def _migrate_unique_constraint(
-        conn: sqlite3.Connection,
-        table: str,
-        create_new_sql: str,
-        columns: str,
-    ) -> None:
-        """Recreate a table with a new UNIQUE constraint if needed.
-
-        Tests whether duplicate folder_order=0 entries can be inserted.
-        If an IntegrityError fires, the old constraint is too narrow and
-        the table must be recreated.
-        """
-        new_table = f"{table}_new"
-        try:
-            # Test: can we insert two rows with same session+folder but different folder_order?
-            # If the old UNIQUE is still (session_id, source_folder) this will fail.
-            conn.execute(f"INSERT INTO {table} (session_id, {columns.split(',')[1].strip()}, folder_order) VALUES (-999, '__test__', 1)")
-            conn.execute(f"INSERT INTO {table} (session_id, {columns.split(',')[1].strip()}, folder_order) VALUES (-999, '__test__', 2)")
-            # Clean up test rows
-            conn.execute(f"DELETE FROM {table} WHERE session_id = -999")
-            # If we got here, the constraint already allows duplicates — no migration needed
-            return
-        except sqlite3.IntegrityError:
-            # Old constraint is too narrow — need to recreate
-            conn.execute(f"DELETE FROM {table} WHERE session_id = -999")
-        except sqlite3.OperationalError:
-            # Column might not exist yet or other issue — try migration anyway
-            conn.execute(f"DELETE FROM {table} WHERE session_id = -999")
-
-        try:
-            conn.execute(f"DROP TABLE IF EXISTS {new_table}")
-            conn.execute(create_new_sql)
-            conn.execute(f"INSERT INTO {new_table} ({columns}) SELECT {columns} FROM {table}")
-            conn.execute(f"DROP TABLE {table}")
-            conn.execute(f"ALTER TABLE {new_table} RENAME TO {table}")
-        except (sqlite3.OperationalError, sqlite3.IntegrityError):
-            # Clean up failed migration attempt
-            try:
-                conn.execute(f"DROP TABLE IF EXISTS {new_table}")
-            except sqlite3.OperationalError:
-                pass
-
-    def clear_session_data(self, session_id: int) -> None:
-        """Delete all data for a session (symlinks, settings, etc.) but keep the session row."""
-        try:
-            with self._connect() as conn:
-                for table in (
-                    'symlinks', 'sequence_trim_settings', 'transition_settings',
-                    'per_transition_settings', 'removed_files', 'direct_transition_settings',
-                ):
-                    conn.execute(f"DELETE FROM {table} WHERE session_id = ?", (session_id,))
-        except sqlite3.Error as e:
-            raise DatabaseError(f"Failed to clear session data: {e}") from e
-
     def _connect(self) -> sqlite3.Connection:
         """Create a database connection with foreign keys enabled."""
         conn = sqlite3.connect(self.db_path)
         conn.execute("PRAGMA foreign_keys = ON")
         return conn
 
-    def create_session(self, destination: str, name: Optional[str] = None) -> int:
+    def create_session(self, destination: str) -> int:
         """Create a new linking session.
 
         Args:
             destination: The destination directory path.
-            name: Optional display name (e.g. "autosave").
 
         Returns:
             The ID of the created session.
@@ -305,8 +138,8 @@ class DatabaseManager:
         try:
             with self._connect() as conn:
                 cursor = conn.execute(
-                    "INSERT INTO symlink_sessions (destination, name) VALUES (?, ?)",
-                    (destination, name)
+                    "INSERT INTO symlink_sessions (destination) VALUES (?)",
+                    (destination,)
                 )
                 return cursor.lastrowid
         except sqlite3.Error as e:
@@ -347,31 +180,6 @@ class DatabaseManager:
         except sqlite3.Error as e:
             raise DatabaseError(f"Failed to record symlink: {e}") from e
 
-    def record_symlinks_batch(
-        self,
-        session_id: int,
-        records: list[tuple[str, str, str, int]],
-    ) -> None:
-        """Record multiple symlinks in a single transaction.
-
-        Args:
-            session_id: The session these symlinks belong to.
-            records: List of (source, link, filename, seq) tuples.
-
-        Raises:
-            DatabaseError: If recording fails.
-        """
-        try:
-            with self._connect() as conn:
-                conn.executemany(
-                    """INSERT INTO symlinks
-                       (session_id, source_path, link_path, original_filename, sequence_number)
-                       VALUES (?, ?, ?, ?, ?)""",
-                    [(session_id, src, lnk, fname, seq) for src, lnk, fname, seq in records]
-                )
-        except sqlite3.Error as e:
-            raise DatabaseError(f"Failed to record symlinks: {e}") from e
-
     def get_sessions(self) -> list[SessionRecord]:
         """List all sessions with link counts.
 
@@ -380,8 +188,7 @@ class DatabaseManager:
         """
         with self._connect() as conn:
             rows = conn.execute("""
-                SELECT s.id, s.created_at, s.destination, COUNT(l.id) as link_count,
-                       s.name, COALESCE(s.locked, 0)
+                SELECT s.id, s.created_at, s.destination, COUNT(l.id) as link_count
                 FROM symlink_sessions s
                 LEFT JOIN symlinks l ON s.id = l.session_id
                 GROUP BY s.id
@@ -393,9 +200,7 @@ class DatabaseManager:
                 id=row[0],
                 created_at=datetime.fromisoformat(row[1]),
                 destination=row[2],
-                link_count=row[3],
-                name=row[4],
-                locked=bool(row[5])
+                link_count=row[3]
             )
             for row in rows
         ]
@@ -465,7 +270,7 @@ class DatabaseManager:
         ]
 
     def delete_session(self, session_id: int) -> None:
-        """Delete a session and all its related data (CASCADE handles child tables).
+        """Delete a session and all its symlink records.
 
         Args:
             session_id: The session ID to delete.
@@ -475,56 +280,11 @@ class DatabaseManager:
         """
         try:
             with self._connect() as conn:
+                conn.execute("DELETE FROM symlinks WHERE session_id = ?", (session_id,))
                 conn.execute("DELETE FROM symlink_sessions WHERE id = ?", (session_id,))
         except sqlite3.Error as e:
             raise DatabaseError(f"Failed to delete session: {e}") from e
 
-    def delete_sessions(self, session_ids: list[int]) -> None:
-        """Delete multiple sessions in a single transaction.
-
-        Locked sessions are silently skipped.
-
-        Args:
-            session_ids: List of session IDs to delete.
-
-        Raises:
-            DatabaseError: If deletion fails.
-        """
-        if not session_ids:
-            return
-        try:
-            with self._connect() as conn:
-                placeholders = ','.join('?' for _ in session_ids)
-                conn.execute(
-                    f"DELETE FROM symlink_sessions WHERE id IN ({placeholders}) AND COALESCE(locked, 0) = 0",
-                    session_ids
-                )
-        except sqlite3.Error as e:
-            raise DatabaseError(f"Failed to delete sessions: {e}") from e
-
-    def toggle_session_locked(self, session_id: int) -> bool:
-        """Toggle the locked state of a session.
-
-        Returns:
-            The new locked state.
-        """
-        try:
-            with self._connect() as conn:
-                row = conn.execute(
-                    "SELECT COALESCE(locked, 0) FROM symlink_sessions WHERE id = ?",
-                    (session_id,)
-                ).fetchone()
-                if row is None:
-                    raise DatabaseError(f"Session {session_id} not found")
-                new_val = 0 if row[0] else 1
-                conn.execute(
-                    "UPDATE symlink_sessions SET locked = ? WHERE id = ?",
-                    (new_val, session_id)
-                )
-                return bool(new_val)
-        except sqlite3.Error as e:
-            raise DatabaseError(f"Failed to toggle session lock: {e}") from e
-
     def get_sessions_by_destination(self, dest: str) -> list[SessionRecord]:
         """Get all sessions for a destination directory.
 
@@ -536,8 +296,7 @@ class DatabaseManager:
         """
         with self._connect() as conn:
             rows = conn.execute("""
-                SELECT s.id, s.created_at, s.destination, COUNT(l.id) as link_count,
-                       s.name, COALESCE(s.locked, 0)
+                SELECT s.id, s.created_at, s.destination, COUNT(l.id) as link_count
                 FROM symlink_sessions s
                 LEFT JOIN symlinks l ON s.id = l.session_id
                 WHERE s.destination = ?
@@ -550,9 +309,7 @@ class DatabaseManager:
                 id=row[0],
                 created_at=datetime.fromisoformat(row[1]),
                 destination=row[2],
-                link_count=row[3],
-                name=row[4],
-                locked=bool(row[5])
+                link_count=row[3]
             )
             for row in rows
         ]
@@ -563,8 +320,7 @@ class DatabaseManager:
         source_folder: str,
         trim_start: int,
         trim_end: int,
-        folder_type: FolderType = FolderType.AUTO,
-        folder_order: int = 0,
+        folder_type: FolderType = FolderType.AUTO
     ) -> None:
         """Save trim settings for a folder in a session.
 
@@ -574,7 +330,6 @@ class DatabaseManager:
             trim_start: Number of images to trim from start.
             trim_end: Number of images to trim from end.
             folder_type: The folder type (auto, main, or transition).
-            folder_order: Position of this folder in source_folders list.
 
         Raises:
             DatabaseError: If saving fails.
@@ -583,14 +338,13 @@ class DatabaseManager:
             with self._connect() as conn:
                 conn.execute(
                     """INSERT INTO sequence_trim_settings
-                       (session_id, source_folder, trim_start, trim_end, folder_type, folder_order)
-                       VALUES (?, ?, ?, ?, ?, ?)
-                       ON CONFLICT(session_id, folder_order)
-                       DO UPDATE SET source_folder=excluded.source_folder,
-                                     trim_start=excluded.trim_start,
+                       (session_id, source_folder, trim_start, trim_end, folder_type)
+                       VALUES (?, ?, ?, ?, ?)
+                       ON CONFLICT(session_id, source_folder)
+                       DO UPDATE SET trim_start=excluded.trim_start,
                                      trim_end=excluded.trim_end,
                                      folder_type=excluded.folder_type""",
-                    (session_id, source_folder, trim_start, trim_end, folder_type.value, folder_order)
+                    (session_id, source_folder, trim_start, trim_end, folder_type.value)
                 )
         except sqlite3.Error as e:
             raise DatabaseError(f"Failed to save trim settings: {e}") from e
@@ -642,62 +396,6 @@ class DatabaseManager:
 
         return {row[0]: (row[1], row[2]) for row in rows}
 
-    def get_all_folder_settings(self, session_id: int) -> dict[str, tuple[int, int, FolderType]]:
-        """Get all folder settings (trim + type) for a session, unordered.
-
-        Returns:
-            Dict mapping source_folder to (trim_start, trim_end, folder_type).
-        """
-        with self._connect() as conn:
-            rows = conn.execute(
-                """SELECT source_folder, trim_start, trim_end, folder_type
-                   FROM sequence_trim_settings WHERE session_id = ?""",
-                (session_id,)
-            ).fetchall()
-
-        result = {}
-        for row in rows:
-            try:
-                ft = FolderType(row[3]) if row[3] else FolderType.AUTO
-            except ValueError:
-                ft = FolderType.AUTO
-            result[row[0]] = (row[1], row[2], ft)
-        return result
-
-    def get_ordered_folders(self, session_id: int) -> list[tuple[str, FolderType, int, int]]:
-        """Get all folders for a session in saved order.
-
-        Returns:
-            List of (source_folder, folder_type, trim_start, trim_end) sorted by folder_order.
-            Returns empty list if folder_order is not meaningful (all zeros from
-            pre-migration sessions), so the caller falls back to symlink-derived order.
-        """
-        with self._connect() as conn:
-            rows = conn.execute(
-                """SELECT source_folder, folder_type, trim_start, trim_end, folder_order
-                   FROM sequence_trim_settings WHERE session_id = ?
-                   ORDER BY folder_order""",
-                (session_id,)
-            ).fetchall()
-
-        if not rows:
-            return []
-
-        # If all folder_order values are 0, this is a pre-migration session
-        # where the ordering is not meaningful — return empty to trigger
-        # the legacy symlink-derived ordering path.
-        if len(rows) > 1 and all(row[4] == 0 for row in rows):
-            return []
-
-        result = []
-        for row in rows:
-            try:
-                ft = FolderType(row[1]) if row[1] else FolderType.AUTO
-            except ValueError:
-                ft = FolderType.AUTO
-            result.append((row[0], ft, row[2], row[3]))
-        return result
-
     def save_transition_settings(
         self,
         session_id: int,
@@ -772,6 +470,41 @@ class DatabaseManager:
             )
         return None
 
+    def save_folder_type_override(
+        self,
+        session_id: int,
+        folder: str,
+        folder_type: FolderType,
+        trim_start: int = 0,
+        trim_end: int = 0
+    ) -> None:
+        """Save folder type override for a folder in a session.
+
+        Args:
+            session_id: The session ID.
+            folder: Path to the source folder.
+            folder_type: The folder type override.
+            trim_start: Number of images to trim from start.
+            trim_end: Number of images to trim from end.
+
+        Raises:
+            DatabaseError: If saving fails.
+        """
+        try:
+            with self._connect() as conn:
+                conn.execute(
+                    """INSERT INTO sequence_trim_settings
+                       (session_id, source_folder, trim_start, trim_end, folder_type)
+                       VALUES (?, ?, ?, ?, ?)
+                       ON CONFLICT(session_id, source_folder)
+                       DO UPDATE SET trim_start=excluded.trim_start,
+                                     trim_end=excluded.trim_end,
+                                     folder_type=excluded.folder_type""",
+                    (session_id, folder, trim_start, trim_end, folder_type.value)
+                )
+        except sqlite3.Error as e:
+            raise DatabaseError(f"Failed to save folder type override: {e}") from e
+
     def get_folder_type_overrides(self, session_id: int) -> dict[str, FolderType]:
         """Get all folder type overrides for a session.
 
@@ -799,15 +532,13 @@ class DatabaseManager:
     def save_per_transition_settings(
         self,
         session_id: int,
-        settings: PerTransitionSettings,
-        folder_order: int = 0,
+        settings: PerTransitionSettings
     ) -> None:
         """Save per-transition overlap settings.
 
         Args:
             session_id: The session ID.
             settings: PerTransitionSettings to save.
-            folder_order: Position of this folder in the source list.
 
         Raises:
             DatabaseError: If saving fails.
@@ -816,13 +547,13 @@ class DatabaseManager:
             with self._connect() as conn:
                 conn.execute(
                     """INSERT INTO per_transition_settings
-                       (session_id, trans_folder, left_overlap, right_overlap, folder_order)
-                       VALUES (?, ?, ?, ?, ?)
-                       ON CONFLICT(session_id, trans_folder, folder_order)
+                       (session_id, trans_folder, left_overlap, right_overlap)
+                       VALUES (?, ?, ?, ?)
+                       ON CONFLICT(session_id, trans_folder)
                        DO UPDATE SET left_overlap=excluded.left_overlap,
                                      right_overlap=excluded.right_overlap""",
                     (session_id, str(settings.trans_folder),
-                     settings.left_overlap, settings.right_overlap, folder_order)
+                     settings.left_overlap, settings.right_overlap)
                 )
         except sqlite3.Error as e:
             raise DatabaseError(f"Failed to save per-transition settings: {e}") from e
@@ -859,109 +590,27 @@ class DatabaseManager:
     def get_all_per_transition_settings(
         self,
         session_id: int
-    ) -> list[tuple[str, int, int, int]]:
+    ) -> dict[str, PerTransitionSettings]:
         """Get all per-transition settings for a session.
 
         Args:
             session_id: The session ID.
 
         Returns:
-            List of (trans_folder, left_overlap, right_overlap, folder_order) tuples.
+            Dict mapping transition folder paths to PerTransitionSettings.
         """
         with self._connect() as conn:
             rows = conn.execute(
-                """SELECT trans_folder, left_overlap, right_overlap, folder_order
-                   FROM per_transition_settings WHERE session_id = ?
-                   ORDER BY folder_order""",
+                """SELECT trans_folder, left_overlap, right_overlap
+                   FROM per_transition_settings WHERE session_id = ?""",
                 (session_id,)
             ).fetchall()
 
-        return [(row[0], row[1], row[2], row[3]) for row in rows]
-
-    def save_removed_files(
-        self,
-        session_id: int,
-        source_folder: str,
-        filenames: list[str],
-        folder_order: int = 0,
-    ) -> None:
-        """Save removed files for a folder in a session.
-
-        Args:
-            session_id: The session ID.
-            source_folder: Path to the source folder.
-            filenames: List of removed filenames.
-            folder_order: Position of this folder in the source list.
-        """
-        try:
-            with self._connect() as conn:
-                for filename in filenames:
-                    conn.execute(
-                        """INSERT OR IGNORE INTO removed_files
-                           (session_id, source_folder, filename, folder_order)
-                           VALUES (?, ?, ?, ?)""",
-                        (session_id, source_folder, filename, folder_order)
-                    )
-        except sqlite3.Error as e:
-            raise DatabaseError(f"Failed to save removed files: {e}") from e
-
-    def get_removed_files(self, session_id: int) -> dict[int, set[str]]:
-        """Get all removed files for a session, keyed by folder_order.
-
-        Args:
-            session_id: The session ID.
-
-        Returns:
-            Dict mapping folder_order to sets of removed filenames.
-        """
-        with self._connect() as conn:
-            rows = conn.execute(
-                "SELECT source_folder, filename, folder_order FROM removed_files WHERE session_id = ?",
-                (session_id,)
-            ).fetchall()
-
-        result: dict[int, set[str]] = {}
-        for folder, filename, folder_order in rows:
-            if folder_order not in result:
-                result[folder_order] = set()
-            result[folder_order].add(filename)
-        return result
-
-    def save_direct_transition(
-        self,
-        session_id: int,
-        after_folder: str,
-        frame_count: int,
-        method: str,
-        enabled: bool,
-        folder_order: int = 0,
-    ) -> None:
-        """Save direct interpolation settings for a folder transition."""
-        try:
-            with self._connect() as conn:
-                conn.execute(
-                    """INSERT INTO direct_transition_settings
-                       (session_id, after_folder, frame_count, method, enabled, folder_order)
-                       VALUES (?, ?, ?, ?, ?, ?)
-                       ON CONFLICT(session_id, after_folder, folder_order)
-                       DO UPDATE SET frame_count=excluded.frame_count,
-                                     method=excluded.method,
-                                     enabled=excluded.enabled""",
-                    (session_id, after_folder, frame_count, method, 1 if enabled else 0, folder_order)
-                )
-        except sqlite3.Error as e:
-            raise DatabaseError(f"Failed to save direct transition: {e}") from e
-
-    def get_direct_transitions(self, session_id: int) -> list[tuple[str, int, str, bool, int]]:
-        """Get direct interpolation settings for a session.
-
-        Returns:
-            List of (after_folder, frame_count, method, enabled, folder_order) tuples.
-        """
-        with self._connect() as conn:
-            rows = conn.execute(
-                "SELECT after_folder, frame_count, method, enabled, folder_order "
-                "FROM direct_transition_settings WHERE session_id = ?",
-                (session_id,)
-            ).fetchall()
-        return [(r[0], r[1], r[2], bool(r[3]), r[4]) for r in rows]
+        return {
+            row[0]: PerTransitionSettings(
+                trans_folder=Path(row[0]),
+                left_overlap=row[1],
+                right_overlap=row[2]
+            )
+            for row in rows
+        }

core/film_worker.py

@@ -1,298 +0,0 @@
-#!/usr/bin/env python
-"""FILM interpolation worker - runs in isolated venv with PyTorch.
-
-This script is executed via subprocess from the main application.
-It handles frame interpolation using Google Research's FILM model
-(Frame Interpolation for Large Motion) via the frame-interpolation-pytorch repo.
-
-FILM is better than RIFE for large motion and scene gaps, but slower.
-
-Supports two modes:
-1. Single frame: --output with --timestep
-2. Batch mode: --output-dir with --frame-count (generates all frames at once)
-"""
-
-import argparse
-import sys
-import urllib.request
-from pathlib import Path
-
-import numpy as np
-import torch
-from PIL import Image
-
-# Model download URL
-FILM_MODEL_URL = "https://github.com/dajes/frame-interpolation-pytorch/releases/download/v1.0.2/film_net_fp32.pt"
-FILM_MODEL_FILENAME = "film_net_fp32.pt"
-
-
-def load_image(path: Path, device: torch.device) -> torch.Tensor:
-    """Load image as tensor.
-
-    Args:
-        path: Path to image file.
-        device: Device to load tensor to.
-
-    Returns:
-        Image tensor (1, 3, H, W) normalized to [0, 1].
-    """
-    img = Image.open(path).convert('RGB')
-    arr = np.array(img).astype(np.float32) / 255.0
-    tensor = torch.from_numpy(arr).permute(2, 0, 1).unsqueeze(0)
-    return tensor.to(device)
-
-
-def save_image(tensor: torch.Tensor, path: Path) -> None:
-    """Save tensor as image.
-
-    Args:
-        tensor: Image tensor (1, 3, H, W) or (3, H, W) normalized to [0, 1].
-        path: Output path.
-    """
-    if tensor.dim() == 4:
-        tensor = tensor.squeeze(0)
-    arr = tensor.permute(1, 2, 0).cpu().numpy()
-    arr = (arr * 255).clip(0, 255).astype(np.uint8)
-    Image.fromarray(arr).save(path)
-
-
-# Global model cache
-_model_cache: dict = {}
-
-
-def download_model(model_dir: Path) -> Path:
-    """Download FILM model if not present.
-
-    Args:
-        model_dir: Directory to store the model.
-
-    Returns:
-        Path to the downloaded model file.
-    """
-    model_dir.mkdir(parents=True, exist_ok=True)
-    model_path = model_dir / FILM_MODEL_FILENAME
-
-    if model_path.exists():
-        # Validate: a valid SavedModel has a saved_model.pb or is a valid file
-        # Quick check: file should be at least 1MB for a real model
-        if model_path.stat().st_size < 1_000_000:
-            print(f"Removing incomplete download at {model_path}", file=sys.stderr)
-            model_path.unlink()
-
-    if not model_path.exists():
-        print(f"Downloading FILM model to {model_path}...", file=sys.stderr)
-        tmp_path = model_path.with_suffix('.tmp')
-        try:
-            urllib.request.urlretrieve(FILM_MODEL_URL, tmp_path)
-            tmp_path.rename(model_path)
-            print("Download complete.", file=sys.stderr)
-        except Exception:
-            tmp_path.unlink(missing_ok=True)
-            raise
-
-    return model_path
-
-
-def get_model(model_dir: Path, device: torch.device):
-    """Get or load FILM model (cached).
-
-    Args:
-        model_dir: Model cache directory (for model downloads).
-        device: Device to run on.
-
-    Returns:
-        FILM TorchScript model instance.
-    """
-    cache_key = f"film_{device}"
-    if cache_key not in _model_cache:
-        # Download model if needed
-        model_path = download_model(model_dir)
-
-        # Load pre-trained TorchScript model
-        print(f"Loading FILM model from {model_path}...", file=sys.stderr)
-        model = torch.jit.load(str(model_path), map_location='cpu')
-        model.eval()
-        model.to(device)
-        _model_cache[cache_key] = model
-        print("Model loaded.", file=sys.stderr)
-
-    return _model_cache[cache_key]
-
-
-@torch.no_grad()
-def interpolate_single(model, img0: torch.Tensor, img1: torch.Tensor, t: float) -> torch.Tensor:
-    """Perform single frame interpolation using FILM.
-
-    Args:
-        model: FILM TorchScript model instance.
-        img0: First frame tensor (1, 3, H, W) normalized to [0, 1].
-        img1: Second frame tensor (1, 3, H, W) normalized to [0, 1].
-        t: Interpolation timestep (0.0 to 1.0).
-
-    Returns:
-        Interpolated frame tensor.
-    """
-    # FILM TorchScript model expects dt as tensor of shape (1, 1)
-    dt = img0.new_full((1, 1), t)
-
-    result = model(img0, img1, dt)
-
-    if isinstance(result, tuple):
-        result = result[0]
-
-    return result.clamp(0, 1)
-
-
-@torch.no_grad()
-def interpolate_batch(model, img0: torch.Tensor, img1: torch.Tensor, frame_count: int) -> list[torch.Tensor]:
-    """Generate multiple interpolated frames using FILM's recursive approach.
-
-    FILM works best when generating frames recursively - it first generates
-    the middle frame, then fills in the gaps. This produces more consistent
-    results than generating arbitrary timesteps independently.
-
-    Args:
-        model: FILM model instance.
-        img0: First frame tensor (1, 3, H, W) normalized to [0, 1].
-        img1: Second frame tensor (1, 3, H, W) normalized to [0, 1].
-        frame_count: Number of frames to generate between img0 and img1.
-
-    Returns:
-        List of interpolated frame tensors in order.
-    """
-    # Calculate timesteps for evenly spaced frames
-    timesteps = [(i + 1) / (frame_count + 1) for i in range(frame_count)]
-
-    # Try to use the model's batch/recursive interpolation if available
-    try:
-        # Some implementations have an interpolate_recursively method
-        if hasattr(model, 'interpolate_recursively'):
-            # This generates 2^n - 1 frames, so we need to handle arbitrary counts
-            results = model.interpolate_recursively(img0, img1, frame_count)
-            if len(results) >= frame_count:
-                return results[:frame_count]
-    except (AttributeError, TypeError):
-        pass
-
-    # Fall back to recursive binary interpolation for better quality
-    # This mimics FILM's natural recursive approach
-    frames = {}  # timestep -> tensor
-
-    def recursive_interpolate(t_left: float, t_right: float, img_left: torch.Tensor, img_right: torch.Tensor, depth: int = 0):
-        """Recursively interpolate to fill the gap."""
-        if depth > 10:  # Prevent infinite recursion
-            return
-
-        t_mid = (t_left + t_right) / 2
-
-        # Check if we need a frame near t_mid
-        need_frame = False
-        for t in timesteps:
-            if t not in frames and abs(t - t_mid) < 0.5 / (frame_count + 1):
-                need_frame = True
-                break
-
-        if not need_frame:
-            # Check if any remaining timesteps are in this range
-            remaining = [t for t in timesteps if t not in frames and t_left < t < t_right]
-            if not remaining:
-                return
-
-        # Generate middle frame
-        mid_frame = interpolate_single(model, img_left, img_right, 0.5)
-
-        # Assign to nearest needed timestep
-        for t in timesteps:
-            if t not in frames and abs(t - t_mid) < 0.5 / (frame_count + 1):
-                frames[t] = mid_frame
-                break
-
-        # Recurse into left and right halves
-        recursive_interpolate(t_left, t_mid, img_left, mid_frame, depth + 1)
-        recursive_interpolate(t_mid, t_right, mid_frame, img_right, depth + 1)
-
-    # Start recursive interpolation
-    recursive_interpolate(0.0, 1.0, img0, img1)
-
-    # Fill any remaining timesteps with direct interpolation
-    for t in timesteps:
-        if t not in frames:
-            frames[t] = interpolate_single(model, img0, img1, t)
-
-    # Return frames in order
-    return [frames[t] for t in timesteps]
-
-
-def main():
-    parser = argparse.ArgumentParser(description='FILM frame interpolation worker')
-    parser.add_argument('--input0', required=True, help='Path to first input image')
-    parser.add_argument('--input1', required=True, help='Path to second input image')
-    parser.add_argument('--output', help='Path to output image (single frame mode)')
-    parser.add_argument('--output-dir', help='Output directory (batch mode)')
-    parser.add_argument('--output-pattern', default='frame_{:04d}.png',
-                        help='Output filename pattern for batch mode')
-    parser.add_argument('--timestep', type=float, default=0.5,
-                        help='Interpolation timestep 0-1 (single frame mode)')
-    parser.add_argument('--frame-count', type=int,
-                        help='Number of frames to generate (batch mode)')
-    parser.add_argument('--repo-dir', help='Unused (kept for backward compat)')
-    parser.add_argument('--model-dir', required=True, help='Model cache directory')
-    parser.add_argument('--device', default='cuda', choices=['cuda', 'cpu'], help='Device to use')
-
-    args = parser.parse_args()
-
-    # Validate arguments
-    batch_mode = args.output_dir is not None and args.frame_count is not None
-    single_mode = args.output is not None
-
-    if not batch_mode and not single_mode:
-        print("Error: Must specify either --output (single) or --output-dir + --frame-count (batch)",
-              file=sys.stderr)
-        return 1
-
-    try:
-        # Select device
-        if args.device == 'cuda' and torch.cuda.is_available():
-            device = torch.device('cuda')
-        else:
-            device = torch.device('cpu')
-
-        # Load model
-        model_dir = Path(args.model_dir)
-        model = get_model(model_dir, device)
-
-        # Load images
-        img0 = load_image(Path(args.input0), device)
-        img1 = load_image(Path(args.input1), device)
-
-        if batch_mode:
-            # Batch mode - generate all frames at once
-            output_dir = Path(args.output_dir)
-            output_dir.mkdir(parents=True, exist_ok=True)
-
-            print(f"Generating {args.frame_count} frames...", file=sys.stderr)
-            frames = interpolate_batch(model, img0, img1, args.frame_count)
-
-            for i, frame in enumerate(frames):
-                output_path = output_dir / args.output_pattern.format(i)
-                save_image(frame, output_path)
-                print(f"Saved {output_path.name}", file=sys.stderr)
-
-            print(f"Success: Generated {len(frames)} frames", file=sys.stderr)
-        else:
-            # Single frame mode
-            result = interpolate_single(model, img0, img1, args.timestep)
-            save_image(result, Path(args.output))
-            print("Success", file=sys.stderr)
-
-        return 0
-
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-        import traceback
-        traceback.print_exc(file=sys.stderr)
-        return 1
-
-
-if __name__ == '__main__':
-    sys.exit(main())

core/manager.py

@@ -80,12 +80,11 @@ class SymlinkManager:
 
     @staticmethod
     def cleanup_old_links(directory: Path) -> int:
-        """Remove existing seq* symlinks and temporary files from a directory.
+        """Remove existing seq* symlinks from a directory.
 
-        Handles all naming formats:
-        - Old folder-indexed: seq01_0000.png
-        - Continuous: seq_00000.png
-        Also removes blended image files and film/bimvfi temp .png files.
+        Handles both old format (seq_0000) and new format (seq01_0000).
+        Also removes blended image files (not just symlinks) created by
+        cross-dissolve transitions.
 
         Args:
             directory: Directory to clean up.
@@ -97,134 +96,31 @@ class SymlinkManager:
             CleanupError: If cleanup fails.
         """
         removed = 0
-        seq_pattern = re.compile(
-            r'^seq\d*_\d+\.(png|jpg|jpeg|webp)$', re.IGNORECASE
-        )
-        temp_pattern = re.compile(
-            r'^((film|bimvfi)_temp_\d+\.png|_fi_\d+\.(png|jpg|jpeg|webp))$', re.IGNORECASE
-        )
+        seq_pattern = re.compile(r'^seq\d*_\d+\.(png|jpg|jpeg|webp)$', re.IGNORECASE)
         try:
             for item in directory.iterdir():
-                should_remove = False
+                # Match both old (seq_NNNN) and new (seqNN_NNNN) formats
                 if item.name.startswith("seq"):
                     if item.is_symlink():
-                        should_remove = True
+                        item.unlink()
+                        removed += 1
                     elif item.is_file() and seq_pattern.match(item.name):
-                        should_remove = True
-                elif item.is_file() and temp_pattern.match(item.name):
-                    should_remove = True
-
-                if should_remove:
-                    item.unlink()
-                    removed += 1
+                        # Also remove blended image files
+                        item.unlink()
+                        removed += 1
         except OSError as e:
             raise CleanupError(f"Failed to clean up old links: {e}") from e
 
         return removed
 
-    @staticmethod
-    def remove_orphan_files(directory: Path, keep_names: set[str]) -> int:
-        """Remove seq* files and film/bimvfi temp files not in the keep set.
-
-        Same pattern matching as cleanup_old_links but skips filenames
-        present in keep_names.
-
-        Args:
-            directory: Directory to clean orphans from.
-            keep_names: Set of filenames to keep.
-
-        Returns:
-            Number of files removed.
-
-        Raises:
-            CleanupError: If removal fails.
-        """
-        removed = 0
-        seq_pattern = re.compile(
-            r'^seq\d*_\d+\.(png|jpg|jpeg|webp)$', re.IGNORECASE
-        )
-        temp_pattern = re.compile(
-            r'^((film|bimvfi)_temp_\d+\.png|_fi_\d+\.(png|jpg|jpeg|webp))$', re.IGNORECASE
-        )
-        try:
-            for item in directory.iterdir():
-                if item.name in keep_names:
-                    continue
-                should_remove = False
-                if item.name.startswith("seq"):
-                    if item.is_symlink():
-                        should_remove = True
-                    elif item.is_file() and seq_pattern.match(item.name):
-                        should_remove = True
-                elif item.is_file() and temp_pattern.match(item.name):
-                    should_remove = True
-
-                if should_remove:
-                    item.unlink()
-                    removed += 1
-        except OSError as e:
-            raise CleanupError(f"Failed to remove orphan files: {e}") from e
-
-        return removed
-
-    @staticmethod
-    def symlink_matches(link_path: Path, expected_source: Path) -> bool:
-        """Check if existing symlink resolves to expected source."""
-        if not link_path.is_symlink():
-            return False
-        try:
-            return link_path.resolve() == expected_source.resolve()
-        except OSError:
-            return False
-
-    @staticmethod
-    def copy_matches(dest_path: Path, source_path: Path) -> bool:
-        """Check if existing copy matches source.
-
-        Fast path: size + mtime comparison.  If sizes match but mtimes
-        differ, falls back to comparing file contents so that a
-        re-export after touching (but not changing) the source is still
-        skipped, while a genuine content change is caught.
-        """
-        if not dest_path.is_file() or dest_path.is_symlink():
-            return False
-        try:
-            src_stat = source_path.stat()
-            dst_stat = dest_path.stat()
-            if src_stat.st_size != dst_stat.st_size:
-                return False
-            # Fast path: identical mtime means the copy2 wrote this file
-            if abs(src_stat.st_mtime - dst_stat.st_mtime) < 2.0:
-                return True
-            # Size matches but mtime differs — compare contents
-            return SymlinkManager._files_equal(source_path, dest_path)
-        except OSError:
-            return False
-
-    @staticmethod
-    def _files_equal(a: Path, b: Path, chunk_size: int = 65536) -> bool:
-        """Compare two files by reading in chunks."""
-        try:
-            with open(a, 'rb') as fa, open(b, 'rb') as fb:
-                while True:
-                    ca = fa.read(chunk_size)
-                    cb = fb.read(chunk_size)
-                    if ca != cb:
-                        return False
-                    if not ca:
-                        return True
-        except OSError:
-            return False
-
     def create_sequence_links(
         self,
         sources: list[Path],
         dest: Path,
         files: list[tuple],
         trim_settings: Optional[dict[Path, tuple[int, int]]] = None,
-        copy_files: bool = False,
     ) -> tuple[list[LinkResult], Optional[int]]:
-        """Create sequenced symlinks or copies from source files to destination.
+        """Create sequenced symlinks from source files to destination.
 
         Args:
             sources: List of source directories (for validation).
@@ -233,12 +129,12 @@ class SymlinkManager:
                    - (source_dir, filename) for CLI mode (uses global sequence)
                    - (source_dir, filename, folder_idx, file_idx) for GUI mode
             trim_settings: Optional dict mapping folder paths to (trim_start, trim_end).
-            copy_files: If True, copy files instead of creating symlinks.
 
         Returns:
             Tuple of (list of LinkResult objects, session_id or None).
         """
         self.validate_paths(sources, dest)
+        self.cleanup_old_links(dest)
 
         session_id = None
         if self.db:
@@ -269,13 +165,6 @@ class SymlinkManager:
                 expanded_files.append((source_dir, filename, folder_idx, file_idx))
             files = expanded_files
 
-        # Build planned names for orphan removal
-        planned_names: set[str] = set()
-        for file_data in files:
-            _, fn, fi, fli = file_data
-            ext = Path(fn).suffix
-            planned_names.add(f"seq{fi + 1:02d}_{fli:04d}{ext}")
-
         for i, file_data in enumerate(files):
             source_dir, filename, folder_idx, file_idx = file_data
             source_path = source_dir / filename
@@ -283,25 +172,11 @@ class SymlinkManager:
             link_name = f"seq{folder_idx + 1:02d}_{file_idx:04d}{ext}"
             link_path = dest / link_name
 
+            # Calculate relative path from destination to source
+            rel_source = Path(os.path.relpath(source_path.resolve(), dest.resolve()))
+
             try:
-                # Check if existing file already matches
-                already_correct = False
-                if link_path.exists() or link_path.is_symlink():
-                    if copy_files:
-                        already_correct = self.copy_matches(link_path, source_path)
-                    else:
-                        already_correct = self.symlink_matches(link_path, source_path)
-
-                if not already_correct:
-                    if link_path.exists() or link_path.is_symlink():
-                        link_path.unlink()
-
-                    if copy_files:
-                        import shutil
-                        shutil.copy2(source_path, link_path)
-                    else:
-                        rel_source = Path(os.path.relpath(source_path.resolve(), dest.resolve()))
-                        link_path.symlink_to(rel_source)
+                link_path.symlink_to(rel_source)
 
                 if self.db and session_id:
                     self.db.record_symlink(
@@ -327,10 +202,4 @@ class SymlinkManager:
                     error=str(e)
                 ))
 
-        # Remove orphan seq*/film_temp_* files not in the planned set
-        try:
-            self.remove_orphan_files(dest, planned_names)
-        except CleanupError:
-            pass
-
         return results, session_id

core/models.py

@@ -32,13 +32,6 @@ class FolderType(Enum):
     TRANSITION = 'transition'
 
 
-class DirectInterpolationMethod(Enum):
-    """Method for direct frame interpolation between sequences."""
-    RIFE = 'rife'
-    FILM = 'film'
-    BIM_VFI = 'bim_vfi'
-
-
 # --- Data Classes ---
 
 @dataclass
@@ -58,54 +51,14 @@ class TransitionSettings:
     # Practical-RIFE settings
     practical_rife_model: str = 'v4.25'  # v4.25, v4.26, v4.22, etc.
     practical_rife_ensemble: bool = False  # Ensemble mode for better quality (slower)
-    # Optical flow settings
-    of_preset: str = 'balanced'  # fast, balanced, quality, max
-    of_levels: int = 3           # pyramid levels (1-7)
-    of_winsize: int = 15         # window size (5-51, odd)
-    of_iterations: int = 3       # iterations (1-10)
-    of_poly_n: int = 5           # polynomial neighborhood (5 or 7)
-    of_poly_sigma: float = 1.2   # gaussian sigma (0.5-2.0)
 
 
 @dataclass
 class PerTransitionSettings:
-    """Per-transition overlap settings for cross-dissolves."""
+    """Per-transition overlap settings for asymmetric cross-dissolves."""
     trans_folder: Path
-    left_overlap: int = 16   # overlap count at left boundary (MAIN→TRANS)
-    right_overlap: int = 16  # overlap count at right boundary (TRANS→MAIN)
-
-
-@dataclass
-class DirectTransitionSettings:
-    """Settings for direct AI interpolation between sequences (no transition folder)."""
-    after_folder: Path  # The folder after which this transition occurs
-    frame_count: int = 16  # Number of interpolated frames to generate
-    method: DirectInterpolationMethod = DirectInterpolationMethod.FILM
-    enabled: bool = True
-
-
-@dataclass
-class VideoPreset:
-    """Preset for video encoding via ffmpeg."""
-    label: str           # Display name
-    container: str       # 'mp4' or 'webm'
-    codec: str           # ffmpeg codec: libx264, libx265, libvpx-vp9, libaom-av1
-    crf: int
-    pixel_format: str = 'yuv420p'
-    preset: str = 'medium'           # x264/x265 speed preset
-    max_height: Optional[int] = None  # Downscale filter
-    extra_args: list[str] = field(default_factory=list)
-
-VIDEO_PRESETS: dict[str, VideoPreset] = {
-    'web_streaming':  VideoPreset('Web Streaming',   'mp4',  'libx264',    23, preset='medium'),
-    'high_quality':   VideoPreset('High Quality',    'mp4',  'libx264',    18, preset='slow'),
-    'archive':        VideoPreset('Archive (H.265)', 'mp4',  'libx265',    18, preset='slow', extra_args=['-tag:v', 'hvc1']),
-    'social_media':   VideoPreset('Social Media',    'mp4',  'libx264',    23, preset='fast', max_height=1080),
-    'fast_preview':   VideoPreset('Fast Preview',    'mp4',  'libx264',    28, preset='ultrafast'),
-    'webm_vp9':       VideoPreset('WebM VP9',        'webm', 'libvpx-vp9', 30, extra_args=['-b:v', '0']),
-    'webm_av1':       VideoPreset('WebM AV1',        'webm', 'libaom-av1', 30, extra_args=['-b:v', '0', '-strict', 'experimental']),
-    'godot_theora':   VideoPreset('Godot (Theora)',   'ogv',  'libtheora',   8, extra_args=['-g', '512']),
-}
+    left_overlap: int = 16   # frames from main folder end
+    right_overlap: int = 16  # frames from trans folder start
 
 
 @dataclass
@@ -131,9 +84,6 @@ class TransitionSpec:
     # Indices into the overall file list
     main_start_idx: int
     trans_start_idx: int
-    # Position indices in the folders list (for duplicate folder support)
-    main_folder_idx: int = 0
-    trans_folder_idx: int = 0
 
 
 @dataclass
@@ -165,8 +115,6 @@ class SessionRecord:
     created_at: datetime
     destination: str
     link_count: int = 0
-    name: Optional[str] = None
-    locked: bool = False
 
 
 # --- Exceptions ---

core/rife_worker.py

@@ -73,22 +73,20 @@ class IFBlock(nn.Module):
         return flow, mask
 
 
-_backwarp_tenGrid = {}
-
-
 def warp(tenInput, tenFlow):
     k = (str(tenFlow.device), str(tenFlow.size()))
-    if k not in _backwarp_tenGrid:
+    backwarp_tenGrid = {}
+    if k not in backwarp_tenGrid:
         tenHorizontal = torch.linspace(-1.0, 1.0, tenFlow.shape[3], device=tenFlow.device).view(
             1, 1, 1, tenFlow.shape[3]).expand(tenFlow.shape[0], -1, tenFlow.shape[2], -1)
         tenVertical = torch.linspace(-1.0, 1.0, tenFlow.shape[2], device=tenFlow.device).view(
             1, 1, tenFlow.shape[2], 1).expand(tenFlow.shape[0], -1, -1, tenFlow.shape[3])
-        _backwarp_tenGrid[k] = torch.cat([tenHorizontal, tenVertical], 1)
+        backwarp_tenGrid[k] = torch.cat([tenHorizontal, tenVertical], 1)
 
     tenFlow = torch.cat([tenFlow[:, 0:1, :, :] / ((tenInput.shape[3] - 1.0) / 2.0),
                          tenFlow[:, 1:2, :, :] / ((tenInput.shape[2] - 1.0) / 2.0)], 1)
 
-    g = (_backwarp_tenGrid[k] + tenFlow).permute(0, 2, 3, 1)
+    g = (backwarp_tenGrid[k] + tenFlow).permute(0, 2, 3, 1)
     return F.grid_sample(input=tenInput, grid=g, mode='bilinear', padding_mode='border', align_corners=True)
 
 

core/video.py

@@ -1,269 +0,0 @@
-"""Video encoding utilities wrapping ffmpeg."""
-
-import re
-import shutil
-import subprocess
-import tempfile
-from pathlib import Path
-from typing import Callable, Optional
-
-from .models import VideoPreset
-
-
-def find_ffmpeg() -> Optional[Path]:
-    """Find the ffmpeg binary on the system PATH."""
-    result = shutil.which('ffmpeg')
-    return Path(result) if result else None
-
-
-def encode_image_sequence(
-    input_dir: Path,
-    output_path: Path,
-    fps: int,
-    preset: VideoPreset,
-    input_pattern: Optional[str] = None,
-    progress_callback: Optional[Callable[[int, int], bool]] = None,
-    total_frames: Optional[int] = None,
-) -> tuple[bool, str]:
-    """Encode an image sequence directory to a video file using ffmpeg.
-
-    Args:
-        input_dir: Directory containing sequentially named image files.
-        output_path: Output video file path.
-        fps: Frames per second.
-        preset: VideoPreset with codec settings.
-        input_pattern: ffmpeg input pattern (e.g. 'seq_%06d.png').
-            Auto-detected from first seq_* file if not provided.
-        progress_callback: Called with (current_frame, total_frames).
-            Return False to cancel encoding.
-        total_frames: Total number of frames for progress reporting.
-            Auto-counted from input_dir if not provided.
-
-    Returns:
-        (success, message) — message is output_path on success or error text on failure.
-    """
-    ffmpeg = find_ffmpeg()
-    if not ffmpeg:
-        return False, "ffmpeg not found. Install ffmpeg to encode video."
-
-    # Auto-detect input pattern from first seq_* file
-    if input_pattern is None:
-        input_pattern = _detect_input_pattern(input_dir)
-        if input_pattern is None:
-            return False, f"No seq_* image files found in {input_dir}"
-
-    # Auto-count frames
-    if total_frames is None:
-        ext = Path(input_pattern).suffix
-        total_frames = len(list(input_dir.glob(f"seq_*{ext}")))
-        if total_frames == 0:
-            return False, f"No matching frames found in {input_dir}"
-
-    # Build ffmpeg command
-    cmd = [
-        str(ffmpeg), '-y',
-        '-framerate', str(fps),
-        '-i', str(input_dir / input_pattern),
-        '-c:v', preset.codec,
-        '-q:v' if preset.codec == 'libtheora' else '-crf', str(preset.crf),
-        '-pix_fmt', preset.pixel_format,
-    ]
-
-    # Add speed preset for x264/x265
-    if preset.codec in ('libx264', 'libx265'):
-        cmd += ['-preset', preset.preset]
-
-    # Add downscale filter if max_height is set
-    if preset.max_height is not None:
-        cmd += ['-vf', f'scale=-2:{preset.max_height}']
-
-    # Add any extra codec-specific args
-    if preset.extra_args:
-        cmd += preset.extra_args
-
-    # Progress parsing via -progress pipe:1
-    cmd += ['-progress', 'pipe:1']
-
-    cmd.append(str(output_path))
-
-    try:
-        proc = subprocess.Popen(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-        )
-
-        try:
-            cancelled = False
-            if proc.stdout:
-                for line in proc.stdout:
-                    line = line.strip()
-                    m = re.match(r'^frame=(\d+)', line)
-                    if m and progress_callback is not None:
-                        current = int(m.group(1))
-                        if not progress_callback(current, total_frames):
-                            cancelled = True
-                            proc.terminate()
-                            break
-
-            proc.wait()
-        except Exception:
-            proc.kill()
-            proc.wait()
-            raise
-
-        if cancelled:
-            # Clean up partial file
-            if output_path.exists():
-                output_path.unlink()
-            return False, "Encoding cancelled by user."
-
-        if proc.returncode != 0:
-            stderr = proc.stderr.read() if proc.stderr else ""
-            return False, f"ffmpeg exited with code {proc.returncode}:\n{stderr}"
-
-        return True, str(output_path)
-
-    except FileNotFoundError:
-        return False, "ffmpeg binary not found."
-    except Exception as e:
-        return False, f"Encoding error: {e}"
-
-
-def _detect_input_pattern(input_dir: Path) -> Optional[str]:
-    """Detect the ffmpeg input pattern from seq_* files in a directory.
-
-    Looks for files like seq_000000.png and returns a pattern like seq_%06d.png.
-    """
-    for f in sorted(input_dir.iterdir()):
-        m = re.match(r'^(seq_)(\d+)(\.\w+)$', f.name)
-        if m:
-            prefix = m.group(1)
-            digits = m.group(2)
-            ext = m.group(3)
-            width = len(digits)
-            return f"{prefix}%0{width}d{ext}"
-    return None
-
-
-def encode_from_file_list(
-    file_paths: list[Path],
-    output_path: Path,
-    fps: int,
-    preset: VideoPreset,
-    progress_callback: Optional[Callable[[int, int], bool]] = None,
-) -> tuple[bool, str]:
-    """Encode a video from an explicit list of image file paths.
-
-    Uses ffmpeg's concat demuxer so files can be scattered across directories.
-
-    Args:
-        file_paths: Ordered list of image file paths.
-        output_path: Output video file path.
-        fps: Frames per second.
-        preset: VideoPreset with codec settings.
-        progress_callback: Called with (current_frame, total_frames).
-            Return False to cancel encoding.
-
-    Returns:
-        (success, message) — message is output_path on success or error text on failure.
-    """
-    ffmpeg = find_ffmpeg()
-    if not ffmpeg:
-        return False, "ffmpeg not found. Install ffmpeg to encode video."
-
-    if not file_paths:
-        return False, "No files provided."
-
-    total_frames = len(file_paths)
-    frame_duration = f"{1.0 / fps:.10f}"
-
-    # Write a concat-demuxer file listing each image with its duration
-    try:
-        concat_file = tempfile.NamedTemporaryFile(
-            mode='w', suffix='.txt', delete=False, prefix='vml_concat_'
-        )
-        concat_path = Path(concat_file.name)
-        try:
-            for p in file_paths:
-                # Escape single quotes for ffmpeg concat format
-                escaped = str(p.resolve()).replace("'", "'\\''")
-                concat_file.write(f"file '{escaped}'\n")
-                concat_file.write(f"duration {frame_duration}\n")
-            # Repeat last file so the last frame displays for its full duration
-            escaped = str(file_paths[-1].resolve()).replace("'", "'\\''")
-            concat_file.write(f"file '{escaped}'\n")
-        finally:
-            concat_file.close()
-    except OSError as e:
-        return False, f"Failed to create concat file: {e}"
-
-    cmd = [
-        str(ffmpeg), '-y',
-        '-f', 'concat', '-safe', '0',
-        '-i', str(concat_path),
-        '-c:v', preset.codec,
-        '-q:v' if preset.codec == 'libtheora' else '-crf', str(preset.crf),
-        '-pix_fmt', preset.pixel_format,
-    ]
-
-    if preset.codec in ('libx264', 'libx265'):
-        cmd += ['-preset', preset.preset]
-
-    if preset.max_height is not None:
-        cmd += ['-vf', f'scale=-2:{preset.max_height}']
-
-    if preset.extra_args:
-        cmd += preset.extra_args
-
-    cmd += ['-progress', 'pipe:1']
-    cmd.append(str(output_path))
-
-    try:
-        proc = subprocess.Popen(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-        )
-
-        try:
-            cancelled = False
-            if proc.stdout:
-                for line in proc.stdout:
-                    line = line.strip()
-                    m = re.match(r'^frame=(\d+)', line)
-                    if m and progress_callback is not None:
-                        current = int(m.group(1))
-                        if not progress_callback(current, total_frames):
-                            cancelled = True
-                            proc.terminate()
-                            break
-
-            proc.wait()
-        except Exception:
-            proc.kill()
-            proc.wait()
-            raise
-
-        if cancelled:
-            if output_path.exists():
-                output_path.unlink()
-            return False, "Encoding cancelled by user."
-
-        if proc.returncode != 0:
-            stderr = proc.stderr.read() if proc.stderr else ""
-            return False, f"ffmpeg exited with code {proc.returncode}:\n{stderr}"
-
-        return True, str(output_path)
-
-    except FileNotFoundError:
-        return False, "ffmpeg binary not found."
-    except Exception as e:
-        return False, f"Encoding error: {e}"
-    finally:
-        try:
-            concat_path.unlink(missing_ok=True)
-        except OSError:
-            pass

ui/widgets.py

@@ -15,7 +15,6 @@ class TrimSlider(QWidget):
     """
 
     trimChanged = pyqtSignal(int, int, str)  # Emits (trim_start, trim_end, 'left' or 'right')
-    trimDragFinished = pyqtSignal(int, int, str)  # Emits final values on mouse release
 
     def __init__(self, parent: Optional[QWidget] = None) -> None:
         """Initialize the trim slider.
@@ -288,11 +287,5 @@ class TrimSlider(QWidget):
 
     def mouseReleaseEvent(self, event: QMouseEvent) -> None:
         """Handle mouse release to stop dragging."""
-        if self._dragging:
-            handle = self._dragging
-            self._dragging = None
-            self.setCursor(Qt.CursorShape.ArrowCursor)
-            self.trimDragFinished.emit(self._trim_start, self._trim_end, handle)
-        else:
-            self._dragging = None
-            self.setCursor(Qt.CursorShape.ArrowCursor)
+        self._dragging = None
+        self.setCursor(Qt.CursorShape.ArrowCursor)