n8n-nodes-sb-render 1.6.2 → 1.6.4

package/README.md

@@ -10,6 +10,8 @@ This is an n8n community node for video rendering with customizable subtitles, b
 - 🎙️ Narration audio with timing control
 - 📝 Customizable subtitles with extensive styling options
 - 🎨 Multiple output formats and quality presets
+- 🖼️ AI-powered parallax effects from static images (Depth Anything V2)
+- 🔀 Video merging with transitions and audio sync
 
 Inspired by [n8n-nodes-mediafx](https://github.com/dandacompany/n8n-nodes-mediafx).
 
@@ -18,6 +20,7 @@ Inspired by [n8n-nodes-mediafx](https://github.com/dandacompany/n8n-nodes-mediaf
 - [Installation](#installation)
 - [Prerequisites](#prerequisites)
 - [Operations](#operations)
+- [Parallax Effect](#parallax-effect)
 - [Configuration](#configuration)
 - [Examples](#examples)
 - [Development](#development)
@@ -99,6 +102,66 @@ Compose a video with optional background music, narration, and subtitles.
 - ✅ Quality presets (Low, Medium, High, Custom)
 - ✅ Smart audio merging (handles mixed audio/silent video inputs)
 
+### Image → Parallax
+
+Create 2.5D parallax video effects from static images using AI depth estimation.
+
+**Features:**
+- ✅ AI-powered depth estimation (Depth Anything V2)
+- ✅ True layer separation with inpainting
+- ✅ Direction + Zoom combination effects
+- ✅ Intensity control (subtle, normal, dramatic)
+- ✅ Falls back to Ken Burns effect if AI not available
+
+## Parallax Effect
+
+The parallax feature uses **Depth Anything V2** AI model to create professional 2.5D parallax effects from static images.
+
+### How It Works
+
+1. **Depth Estimation**: AI model analyzes the image to create a depth map
+2. **Layer Separation**: Foreground is extracted based on depth (closer objects)
+3. **Inpainting**: Background is filled where foreground was removed
+4. **Animation**: Layers move at different speeds creating parallax illusion
+
+### Parameters
+
+| Parameter | Type | Options | Description |
+|-----------|------|---------|-------------|
+| **direction** | String | `left`, `right`, `up`, `down` | Pan direction |
+| **zoom** | String | `none`, `in`, `out` | Zoom effect (combinable with direction) |
+| **intensity** | String | `subtle`, `normal`, `dramatic` | Movement intensity |
+| **duration** | Number | seconds | Video duration |
+
+### Combined Effects
+
+You can combine zoom with direction for richer effects:
+
+```json
+{
+  "direction": "left",
+  "zoom": "in",
+  "intensity": "normal",
+  "duration": 5
+}
+```
+
+**Effect Combinations:**
+- `left` + `zoomIn`: Pan left while zooming in
+- `right` + `zoomOut`: Pan right while zooming out
+- `up` + `zoomIn`: Pan up with zoom in
+- `zoomIn` only: Pure zoom in effect (set direction to empty)
+
+### Requirements for AI Parallax
+
+For AI-powered depth parallax, the following Python packages are required on the server:
+
+```bash
+pip3 install torch transformers pillow opencv-python-headless
+```
+
+If not available, the node automatically falls back to Ken Burns (zoompan) effect.
+
 ## Configuration
 
 ### Video Input

package/dist/nodes/SbRender/services/ParallaxEngine.d.ts

@@ -1,9 +1,11 @@
 export type ParallaxDirection = 'left' | 'right' | 'up' | 'down' | 'zoomIn' | 'zoomOut';
 export type ParallaxIntensity = 'subtle' | 'normal' | 'dramatic';
+export type ParallaxZoom = 'none' | 'in' | 'out';
 export interface ParallaxConfig {
     direction: ParallaxDirection;
     intensity: ParallaxIntensity;
     layerCount?: number;
+    zoom?: ParallaxZoom;
 }
 export declare class ParallaxEngine {
     private sharpAvailable;
@@ -19,6 +21,7 @@ export declare class ParallaxEngine {
     /**
      * Generate parallax video from a single image
      * Main entry point for creating parallax effect videos
+     * Uses AI depth estimation for true parallax, falls back to Ken Burns
      */
     generateParallaxVideo(imagePath: string, outputPath: string, config: ParallaxConfig, duration: number, fps?: number, _videoCodec?: string, _quality?: string, _customCRF?: number): Promise<Buffer>;
     /**

package/dist/nodes/SbRender/services/ParallaxEngine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParallaxEngine.d.ts","sourceRoot":"","sources":["../../../../nodes/SbRender/services/ParallaxEngine.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;AACxF,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEjE,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,iBAAiB,CAAC;IAC7B,SAAS,EAAE,iBAAiB,CAAC;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAkdD,qBAAa,cAAc;IACzB,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,WAAW,CAAS;IAE5B;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IASjC;;OAEG;IACH,wBAAwB,IAAI,OAAO;IAInC;;;OAGG;IACG,qBAAqB,CACzB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,MAAM,EAChB,GAAG,SAAK,EACR,WAAW,SAAY,EACvB,QAAQ,SAAS,EACjB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,CAAC;IAkDlB;;OAEG;IACG,sBAAsB,CAC1B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,MAAM,EAChB,GAAG,SAAK,GACP,OAAO,CAAC,MAAM,EAAE,CAAC;CAKrB;AAGD,eAAO,MAAM,cAAc,gBAAuB,CAAC"}
+{"version":3,"file":"ParallaxEngine.d.ts","sourceRoot":"","sources":["../../../../nodes/SbRender/services/ParallaxEngine.ts"],"names":[],"mappings":"AAoIA,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;AACxF,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,QAAQ,GAAG,UAAU,CAAC;AACjE,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,IAAI,GAAG,KAAK,CAAC;AAEjD,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,iBAAiB,CAAC;IAC7B,SAAS,EAAE,iBAAiB,CAAC;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,YAAY,CAAC;CACrB;AA8KD,qBAAa,cAAc;IACzB,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,WAAW,CAAS;IAE5B;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IASjC;;OAEG;IACH,wBAAwB,IAAI,OAAO;IAInC;;;;OAIG;IACG,qBAAqB,CACzB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,MAAM,EAChB,GAAG,SAAK,EACR,WAAW,SAAY,EACvB,QAAQ,SAAS,EACjB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,CAAC;IAyElB;;OAEG;IACG,sBAAsB,CAC1B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,MAAM,EAChB,GAAG,SAAK,GACP,OAAO,CAAC,MAAM,EAAE,CAAC;CAKrB;AAGD,eAAO,MAAM,cAAc,gBAAuB,CAAC"}

package/dist/nodes/SbRender/services/ParallaxEngine.js

@@ -45,304 +45,181 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const ffmpeg_wrapper_1 = require("../utils/ffmpeg-wrapper");
 const child_process_1 = require("child_process");
-// Try to load sharp (optional dependency)
-let sharp = null;
-async function loadSharp() {
-    if (sharp !== null)
-        return true;
-    try {
-        sharp = (await Promise.resolve().then(() => __importStar(require('sharp')))).default;
-        console.log('[ParallaxEngine] Sharp loaded successfully');
-        return true;
-    }
-    catch (error) {
-        console.warn('[ParallaxEngine] Sharp not available:', error.message);
-        return false;
+// Path to the depth parallax Python script
+// In compiled code, __dirname is dist/nodes/SbRender/services/
+// Script is at project_root/scripts/depth_parallax.py
+const DEPTH_SCRIPT_PATH = path.join(__dirname, '../../../../scripts/depth_parallax.py');
+// Python executable path - prefer mounted venv, fallback to system python3
+const PYTHON_PATHS = ['/opt/venv/bin/python3', 'python3'];
+let pythonPath = null;
+// Check if Python depth estimation is available
+let pythonDepthAvailable = null;
+function findPythonPath() {
+    for (const pyPath of PYTHON_PATHS) {
+        try {
+            (0, child_process_1.execSync)(`${pyPath} -c "import torch; import transformers"`, { stdio: 'pipe' });
+            console.log(`[ParallaxEngine] Found working Python at: ${pyPath}`);
+            return pyPath;
+        }
+        catch {
+            // Try next path
+        }
     }
+    return null;
 }
-/**
- * Get motion parameters based on intensity
- */
-function getIntensityParams(intensity) {
-    switch (intensity) {
-        case 'subtle':
-            return { fgSpeed: 0.04, bgSpeed: 0.015, scaleRange: 0.02 };
-        case 'normal':
-            return { fgSpeed: 0.08, bgSpeed: 0.025, scaleRange: 0.04 };
-        case 'dramatic':
-            return { fgSpeed: 0.15, bgSpeed: 0.04, scaleRange: 0.08 };
-        default:
-            return { fgSpeed: 0.08, bgSpeed: 0.025, scaleRange: 0.04 };
+async function checkPythonDepth() {
+    if (pythonDepthAvailable !== null)
+        return pythonDepthAvailable;
+    pythonPath = findPythonPath();
+    if (pythonPath && fs.existsSync(DEPTH_SCRIPT_PATH)) {
+        pythonDepthAvailable = true;
+        console.log('[ParallaxEngine] Python depth estimation available');
     }
-}
-/**
- * Create a gradient mask for layer separation
- * Returns RGBA buffer where alpha determines visibility
- */
-function createGradientMask(width, height, type, layerIndex, totalLayers) {
-    // Create RGBA buffer
-    const buffer = Buffer.alloc(width * height * 4);
-    // Calculate layer boundaries
-    const layerHeight = height / totalLayers;
-    const layerStart = (totalLayers - 1 - layerIndex) * layerHeight; // Reverse: top layers are background
-    const layerEnd = layerStart + layerHeight;
-    // Feather zone for smooth transitions
-    const featherSize = layerHeight * 0.3;
-    for (let y = 0; y < height; y++) {
-        let alpha = 0;
-        if (y >= layerStart && y < layerEnd) {
-            // Inside layer
-            alpha = 255;
-            // Apply feathering at edges
-            if (y < layerStart + featherSize) {
-                alpha = Math.floor(((y - layerStart) / featherSize) * 255);
-            }
-            else if (y > layerEnd - featherSize) {
-                alpha = Math.floor(((layerEnd - y) / featherSize) * 255);
-            }
-        }
-        else if (y < layerStart && y > layerStart - featherSize) {
-            // Fade in from above
-            alpha = Math.floor(((layerStart - y) / featherSize) * 128);
-        }
-        else if (y >= layerEnd && y < layerEnd + featherSize) {
-            // Fade out below
-            alpha = Math.floor(((y - layerEnd) / featherSize) * 128);
-        }
-        // For foreground (bottom), extend fully to bottom
-        if (type === 'foreground' && layerIndex === 0 && y >= layerStart) {
-            alpha = 255;
+    else {
+        pythonDepthAvailable = false;
+        if (!pythonPath) {
+            console.log('[ParallaxEngine] Python depth estimation not available (missing torch/transformers)');
         }
-        // For background (top), extend fully to top
-        if (type === 'background' && layerIndex === totalLayers - 1 && y <= layerEnd) {
-            alpha = 255;
-        }
-        for (let x = 0; x < width; x++) {
-            const idx = (y * width + x) * 4;
-            buffer[idx] = 255; // R
-            buffer[idx + 1] = 255; // G
-            buffer[idx + 2] = 255; // B
-            buffer[idx + 3] = alpha; // A
+        else {
+            console.log('[ParallaxEngine] Depth script not found:', DEPTH_SCRIPT_PATH);
         }
     }
-    return buffer;
+    return pythonDepthAvailable;
 }
 /**
- * Generate true multi-layer parallax with actual layer separation
+ * Generate parallax using AI depth estimation (Python + Depth Anything)
+ * Creates true layer separation based on depth map
  */
-async function generateLayeredParallax(imagePath, outputPath, config, duration, fps, width, height) {
-    if (!sharp) {
-        throw new Error('Sharp not available for parallax');
-    }
-    const params = getIntensityParams(config.intensity);
-    const totalFrames = Math.ceil(duration * fps);
-    const numLayers = config.layerCount || 3;
-    const tempDir = path.join(path.dirname(outputPath), `parallax_temp_${Date.now()}`);
-    console.log(`[ParallaxEngine] Creating ${numLayers}-layer parallax effect`);
-    console.log(`[ParallaxEngine] Direction: ${config.direction}, Intensity: ${config.intensity}`);
-    try {
-        fs.mkdirSync(tempDir, { recursive: true });
-        // Load and prepare the source image
-        const sourceBuffer = await sharp(imagePath)
-            .resize(width, height, { fit: 'cover', position: 'center' })
-            .ensureAlpha()
-            .raw()
-            .toBuffer({ resolveWithObject: true });
-        const { data: sourceData, info } = sourceBuffer;
-        const imgWidth = info.width;
-        const imgHeight = info.height;
-        console.log(`[ParallaxEngine] Source image: ${imgWidth}x${imgHeight}`);
-        // Pre-calculate layer masks
-        const layerMasks = [];
-        for (let i = 0; i < numLayers; i++) {
-            const type = i === 0 ? 'foreground' : i === numLayers - 1 ? 'background' : 'middle';
-            layerMasks.push(createGradientMask(imgWidth, imgHeight, type, i, numLayers));
-        }
-        // Generate each frame
-        console.log(`[ParallaxEngine] Generating ${totalFrames} frames...`);
-        for (let frameNum = 0; frameNum < totalFrames; frameNum++) {
-            // Progress from -1 to 1 (centered animation)
-            const progress = ((frameNum / (totalFrames - 1)) - 0.5) * 2;
-            // Start with a base canvas (slightly larger for movement headroom)
-            const canvasWidth = Math.floor(imgWidth * 1.2);
-            const canvasHeight = Math.floor(imgHeight * 1.2);
-            // Create composites array for all layers
-            const composites = [];
-            // Process each layer (background to foreground)
-            for (let layerIdx = numLayers - 1; layerIdx >= 0; layerIdx--) {
-                // Calculate movement for this layer
-                // Background layers (higher index) move less, foreground layers move more
-                const depthFactor = layerIdx / (numLayers - 1); // 0 = foreground, 1 = background
-                const layerSpeed = params.bgSpeed + (params.fgSpeed - params.bgSpeed) * (1 - depthFactor);
-                let offsetX = 0;
-                let offsetY = 0;
-                let scale = 1.0;
-                switch (config.direction) {
-                    case 'left':
-                        offsetX = Math.round(progress * layerSpeed * imgWidth);
-                        break;
-                    case 'right':
-                        offsetX = Math.round(-progress * layerSpeed * imgWidth);
-                        break;
-                    case 'up':
-                        offsetY = Math.round(progress * layerSpeed * imgHeight);
-                        break;
-                    case 'down':
-                        offsetY = Math.round(-progress * layerSpeed * imgHeight);
-                        break;
-                    case 'zoomIn':
-                        scale = 1 + (progress + 1) * params.scaleRange * (1 - depthFactor * 0.5);
-                        break;
-                    case 'zoomOut':
-                        scale = 1 + (1 - progress) * params.scaleRange * (1 - depthFactor * 0.5);
-                        break;
+async function generateDepthParallax(imagePath, outputPath, config, duration, fps) {
+    return new Promise((resolve, reject) => {
+        const options = JSON.stringify({
+            direction: config.direction,
+            intensity: config.intensity,
+            duration,
+            fps,
+            layerCount: config.layerCount || 3,
+            zoom: config.zoom || 'none',
+        });
+        const pyExe = pythonPath || 'python3';
+        console.log(`[ParallaxEngine] Running depth estimation: ${pyExe} ${DEPTH_SCRIPT_PATH}`);
+        const proc = (0, child_process_1.spawn)(pyExe, [DEPTH_SCRIPT_PATH, imagePath, outputPath, options], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout.on('data', (data) => { stdout += data.toString(); });
+        proc.stderr.on('data', (data) => {
+            stderr += data.toString();
+            // Log progress messages
+            const lines = data.toString().split('\n');
+            for (const line of lines) {
+                if (line.trim()) {
+                    console.log(`[DepthParallax] ${line.trim()}`);
                 }
-                // Apply mask to source image to create this layer
-                const mask = layerMasks[layerIdx];
-                const layerData = Buffer.alloc(imgWidth * imgHeight * 4);
-                for (let i = 0; i < imgWidth * imgHeight; i++) {
-                    const srcIdx = i * 4;
-                    const maskAlpha = mask[srcIdx + 3];
-                    layerData[srcIdx] = sourceData[srcIdx]; // R
-                    layerData[srcIdx + 1] = sourceData[srcIdx + 1]; // G
-                    layerData[srcIdx + 2] = sourceData[srcIdx + 2]; // B
-                    layerData[srcIdx + 3] = maskAlpha; // A from mask
+            }
+        });
+        proc.on('close', (code) => {
+            if (code !== 0) {
+                console.error('[ParallaxEngine] Depth parallax failed:', stderr);
+                reject(new Error(`Depth parallax failed with code ${code}: ${stderr}`));
+                return;
+            }
+            try {
+                const result = JSON.parse(stdout);
+                if (result.success) {
+                    console.log('[ParallaxEngine] Depth parallax completed successfully');
+                    resolve();
                 }
-                // Create the layer image with transformations
-                let layerImage = sharp(layerData, {
-                    raw: { width: imgWidth, height: imgHeight, channels: 4 },
-                });
-                // Apply scale if needed
-                if (scale !== 1.0) {
-                    const scaledWidth = Math.round(imgWidth * scale);
-                    const scaledHeight = Math.round(imgHeight * scale);
-                    layerImage = layerImage.resize(scaledWidth, scaledHeight, { fit: 'fill' });
-                    // Extract center portion back to original size
-                    const cropX = Math.floor((scaledWidth - imgWidth) / 2);
-                    const cropY = Math.floor((scaledHeight - imgHeight) / 2);
-                    layerImage = layerImage.extract({
-                        left: Math.max(0, cropX),
-                        top: Math.max(0, cropY),
-                        width: Math.min(imgWidth, scaledWidth),
-                        height: Math.min(imgHeight, scaledHeight),
-                    });
+                else {
+                    reject(new Error(result.error || 'Unknown error'));
                 }
-                const layerBuffer = await layerImage.ensureAlpha().raw().toBuffer();
-                // Calculate position on canvas
-                const baseX = Math.floor((canvasWidth - imgWidth) / 2);
-                const baseY = Math.floor((canvasHeight - imgHeight) / 2);
-                composites.push({
-                    input: layerBuffer,
-                    raw: { width: imgWidth, height: imgHeight, channels: 4 },
-                    left: baseX + offsetX,
-                    top: baseY + offsetY,
-                    blend: 'over',
-                });
-            }
-            // Create the final frame by compositing all layers
-            let frame = sharp({
-                create: {
-                    width: canvasWidth,
-                    height: canvasHeight,
-                    channels: 4,
-                    background: { r: 0, g: 0, b: 0, alpha: 255 },
-                },
-            });
-            // Add each layer
-            for (const comp of composites) {
-                frame = sharp(await frame.png().toBuffer()).composite([{
-                        input: comp.input,
-                        raw: comp.raw,
-                        left: comp.left,
-                        top: comp.top,
-                        blend: comp.blend,
-                    }]);
             }
-            // Extract the center portion at original size
-            const cropX = Math.floor((canvasWidth - imgWidth) / 2);
-            const cropY = Math.floor((canvasHeight - imgHeight) / 2);
-            const framePath = path.join(tempDir, `frame_${String(frameNum).padStart(5, '0')}.png`);
-            await frame
-                .extract({ left: cropX, top: cropY, width: imgWidth, height: imgHeight })
-                .png()
-                .toFile(framePath);
-            if (frameNum % Math.max(1, Math.floor(totalFrames / 10)) === 0) {
-                console.log(`[ParallaxEngine] Frame ${frameNum + 1}/${totalFrames}`);
+            catch {
+                // If no JSON output, assume success if file exists
+                if (fs.existsSync(outputPath)) {
+                    resolve();
+                }
+                else {
+                    reject(new Error('Depth parallax failed: no output file'));
+                }
             }
-        }
-        // Combine frames into video using FFmpeg
-        console.log('[ParallaxEngine] Combining frames into video...');
-        const inputPattern = path.join(tempDir, 'frame_%05d.png');
-        await new Promise((resolve, reject) => {
-            const command = (0, ffmpeg_wrapper_1.createCommand)();
-            command
-                .input(inputPattern)
-                .inputOptions([`-framerate ${fps}`])
-                .outputOptions([
-                '-c:v libx264',
-                '-crf 18',
-                '-preset medium',
-                '-pix_fmt yuv420p',
-                '-movflags +faststart',
-            ])
-                .format('mp4')
-                .output(outputPath);
-            command.on('start', (cmd) => {
-                console.log(`[ParallaxEngine] FFmpeg: ${cmd}`);
-            });
-            command.on('error', (err) => reject(err));
-            command.on('end', () => resolve());
-            command.run();
         });
-        console.log('[ParallaxEngine] Parallax video created successfully');
+        proc.on('error', (err) => {
+            console.error('[ParallaxEngine] Failed to spawn Python process:', err);
+            reject(err);
+        });
+    });
+}
+// Try to load sharp (optional dependency)
+let sharp = null;
+async function loadSharp() {
+    if (sharp !== null)
+        return true;
+    try {
+        sharp = (await Promise.resolve().then(() => __importStar(require('sharp')))).default;
+        console.log('[ParallaxEngine] Sharp loaded successfully');
+        return true;
     }
-    finally {
-        // Cleanup temp directory
-        if (fs.existsSync(tempDir)) {
-            fs.rmSync(tempDir, { recursive: true, force: true });
-        }
+    catch (error) {
+        console.warn('[ParallaxEngine] Sharp not available:', error.message);
+        return false;
     }
 }
 /**
- * Fallback: Simple Ken Burns effect using FFmpeg zoompan
- * Used when sharp is not available
+ * Ken Burns effect using zoompan with optimized settings
+ * Uses higher zoom and stronger movement for visible parallax
  */
 async function generateSimpleKenBurns(imagePath, outputPath, config, duration, fps, width, height) {
-    const params = getIntensityParams(config.intensity);
     const totalFrames = Math.ceil(duration * fps);
+    // Movement intensity - increased for more visible effect
+    const intensityMultiplier = config.intensity === 'subtle' ? 0.7 :
+        config.intensity === 'dramatic' ? 1.6 : 1.0;
+    // Higher base zoom for smoother subpixel movement
+    const baseZoom = 1.3;
+    // Stronger zoom change
+    const zoomDelta = 0.12 * intensityMultiplier;
+    // Stronger pan movement (percentage of available space)
+    const panSpeed = 0.15 * intensityMultiplier;
     let zoomExpr;
     let xExpr;
     let yExpr;
-    const baseZoom = 1.15;
-    const zoomDelta = params.scaleRange;
+    // Smooth easing using sine function for natural movement
+    // on = frame number, goes from 0 to totalFrames
+    // Using smooth start/end with sine easing
+    const progress = `on/${totalFrames}`;
+    const easeInOut = `(1-cos(${progress}*PI))/2`;
     switch (config.direction) {
         case 'left':
-            zoomExpr = `${baseZoom}+${zoomDelta}*on/${totalFrames}`;
-            xExpr = `(iw-ow)/2-${params.fgSpeed}*iw*on/${totalFrames}`;
+            // Pan from right to left
+            zoomExpr = `${baseZoom}+${zoomDelta}*${progress}`;
+            xExpr = `(iw-ow)/2*(1+${panSpeed})-${panSpeed}*(iw-ow)/2*${easeInOut}*2`;
             yExpr = `(ih-oh)/2`;
             break;
         case 'right':
-            zoomExpr = `${baseZoom}+${zoomDelta}*on/${totalFrames}`;
-            xExpr = `(iw-ow)/2+${params.fgSpeed}*iw*on/${totalFrames}`;
+            // Pan from left to right
+            zoomExpr = `${baseZoom}+${zoomDelta}*${progress}`;
+            xExpr = `(iw-ow)/2*(1-${panSpeed})+${panSpeed}*(iw-ow)/2*${easeInOut}*2`;
             yExpr = `(ih-oh)/2`;
             break;
         case 'up':
-            zoomExpr = `${baseZoom}+${zoomDelta}*on/${totalFrames}`;
+            // Pan from bottom to top
+            zoomExpr = `${baseZoom}+${zoomDelta}*${progress}`;
             xExpr = `(iw-ow)/2`;
-            yExpr = `(ih-oh)/2-${params.fgSpeed}*ih*on/${totalFrames}`;
+            yExpr = `(ih-oh)/2*(1+${panSpeed})-${panSpeed}*(ih-oh)/2*${easeInOut}*2`;
             break;
         case 'down':
-            zoomExpr = `${baseZoom}+${zoomDelta}*on/${totalFrames}`;
+            // Pan from top to bottom
+            zoomExpr = `${baseZoom}+${zoomDelta}*${progress}`;
             xExpr = `(iw-ow)/2`;
-            yExpr = `(ih-oh)/2+${params.fgSpeed}*ih*on/${totalFrames}`;
+            yExpr = `(ih-oh)/2*(1-${panSpeed})+${panSpeed}*(ih-oh)/2*${easeInOut}*2`;
             break;
         case 'zoomIn':
-            zoomExpr = `${baseZoom}+${zoomDelta * 3}*on/${totalFrames}`;
+            zoomExpr = `${baseZoom}+${zoomDelta * 2.5}*${easeInOut}`;
             xExpr = `(iw-ow)/2`;
             yExpr = `(ih-oh)/2`;
             break;
         case 'zoomOut':
-            zoomExpr = `${baseZoom + zoomDelta * 3}-${zoomDelta * 3}*on/${totalFrames}`;
+            zoomExpr = `${baseZoom + zoomDelta * 2.5}-${zoomDelta * 2.5}*${easeInOut}`;
             xExpr = `(iw-ow)/2`;
             yExpr = `(ih-oh)/2`;
             break;
@@ -351,12 +228,13 @@ async function generateSimpleKenBurns(imagePath, outputPath, config, duration, f
             xExpr = `(iw-ow)/2`;
             yExpr = `(ih-oh)/2`;
     }
-    const zoompanFilter = `zoompan=z='${zoomExpr}':x='${xExpr}':y='${yExpr}':d=${totalFrames}:s=${width}x${height}:fps=${fps}`;
+    // zoompan filter with smooth interpolation
+    const filterChain = `zoompan=z='${zoomExpr}':x='${xExpr}':y='${yExpr}':d=${totalFrames}:s=${width}x${height}:fps=${fps}`;
     return new Promise((resolve, reject) => {
         const command = (0, ffmpeg_wrapper_1.createCommand)(imagePath);
         command
             .inputOptions(['-loop 1'])
-            .videoFilters([zoompanFilter])
+            .videoFilters([filterChain])
             .outputOptions([
             `-t ${duration}`,
             '-pix_fmt yuv420p',
@@ -443,6 +321,7 @@ class ParallaxEngine {
     /**
      * Generate parallax video from a single image
      * Main entry point for creating parallax effect videos
+     * Uses AI depth estimation for true parallax, falls back to Ken Burns
      */
     async generateParallaxVideo(imagePath, outputPath, config, duration, fps = 24, _videoCodec = 'libx264', _quality = 'high', _customCRF) {
         await this.initialize();
@@ -453,15 +332,17 @@ class ParallaxEngine {
         const width = Math.floor(dimensions.width / 2) * 2; // Ensure even
         const height = Math.floor(dimensions.height / 2) * 2;
         console.log(`[ParallaxEngine] Output size: ${width}x${height}`);
+        // Check if Python depth estimation is available
+        const depthAvailable = await checkPythonDepth();
         try {
-            if (this.sharpAvailable) {
-                // Use true multi-layer parallax
-                console.log('[ParallaxEngine] Using multi-layer parallax mode');
-                await generateLayeredParallax(imagePath, outputPath, { ...config, layerCount: config.layerCount || 3 }, duration, fps, width, height);
+            if (depthAvailable) {
+                // Use AI depth-based parallax for true layer separation
+                console.log('[ParallaxEngine] Using AI depth-based parallax (Depth Anything V2)');
+                await generateDepthParallax(imagePath, outputPath, config, duration, fps);
             }
             else {
-                // Fallback to simple Ken Burns
-                console.log('[ParallaxEngine] Using Ken Burns fallback (sharp not available)');
+                // Fall back to Ken Burns effect
+                console.log('[ParallaxEngine] Using Ken Burns effect (depth estimation not available)');
                 await generateSimpleKenBurns(imagePath, outputPath, config, duration, fps, width, height);
             }
             const buffer = fs.readFileSync(outputPath);
@@ -470,6 +351,19 @@ class ParallaxEngine {
         }
         catch (error) {
             console.error('[ParallaxEngine] Error generating parallax:', error);
+            // If depth parallax failed, try Ken Burns as fallback
+            if (depthAvailable) {
+                console.log('[ParallaxEngine] Depth parallax failed, falling back to Ken Burns');
+                try {
+                    await generateSimpleKenBurns(imagePath, outputPath, config, duration, fps, width, height);
+                    const buffer = fs.readFileSync(outputPath);
+                    return buffer;
+                }
+                catch (fallbackError) {
+                    console.error('[ParallaxEngine] Ken Burns fallback also failed:', fallbackError);
+                    throw fallbackError;
+                }
+            }
             throw error;
         }
     }