@lee-jisoo/n8n-nodes-mediafx 1.6.26 → 1.6.28

package/README.md

@@ -10,6 +10,21 @@ This is a custom n8n node for comprehensive, local media processing using FFmpeg
 
 ## 🆕 What's New in This Fork
 
+### v1.6.28
+**New Features**
+
+- **📝 Multi-line Center Alignment**: Each line is individually centered
+  - Works with older FFmpeg versions (no text_align dependency)
+  - Each line rendered as separate drawtext filter
+  - Line spacing option supported
+
+### v1.6.27
+**Improvements**
+
+- **🔧 FFmpeg Bundling Fix**: Now uses `ffmpeg-static` (FFmpeg 5.x) as primary source
+  - More reliable cross-platform support
+  - Fixes issues with old system FFmpeg being used instead of bundled version
+
 ### v1.6.26
 **New Features**
 

package/dist/nodes/MediaFX/operations/addTextToImage.js

@@ -145,37 +145,6 @@ paddingX = 20) {
     fontSize = Math.max(12, Math.min(fontSize, 500));
     return fontSize;
 }
-function getPositionFromAlignment(horizontalAlign, verticalAlign, paddingX, paddingY) {
-    let x;
-    let y;
-    // Set X position based on horizontal alignment
-    switch (horizontalAlign) {
-        case 'left':
-            x = `${paddingX}`;
-            break;
-        case 'right':
-            x = `w-text_w-${paddingX}`;
-            break;
-        case 'center':
-        default:
-            x = '(w-text_w)/2';
-            break;
-    }
-    // Set Y position based on vertical alignment
-    switch (verticalAlign) {
-        case 'top':
-            y = `${paddingY}`;
-            break;
-        case 'bottom':
-            y = `h-th-${paddingY}`;
-            break;
-        case 'middle':
-        default:
-            y = '(h-text_h)/2';
-            break;
-    }
-    return { x, y };
-}
 async function executeAddTextToImage(imagePath, text, options, itemIndex) {
     var _a, _b, _c, _d;
     // Get font (includes bundled, user, and system fonts)
@@ -204,8 +173,8 @@ async function executeAddTextToImage(imagePath, text, options, itemIndex) {
         fontSize = sizeOption || 48;
     }
     const fontColor = options.color || 'white';
-    const textAlign = options.textAlign || 'left';
     const lineSpacing = (_c = options.lineSpacing) !== null && _c !== void 0 ? _c : 10;
+    const horizontalAlign = options.horizontalAlign || 'center';
     // Outline options
     const outlineWidth = options.outlineWidth || 0;
     const outlineColor = options.outlineColor || 'black';
@@ -214,22 +183,6 @@ async function executeAddTextToImage(imagePath, text, options, itemIndex) {
     const backgroundColor = options.backgroundColor || 'black';
     const backgroundOpacity = (_d = options.backgroundOpacity) !== null && _d !== void 0 ? _d : 0.5;
     const boxPadding = options.boxPadding || 5;
-    // Handle position based on position type
-    let positionX;
-    let positionY;
-    const positionType = options.positionType || 'alignment';
-    if (positionType === 'alignment') {
-        const horizontalAlign = options.horizontalAlign || 'center';
-        const verticalAlign = options.verticalAlign || 'middle';
-        const position = getPositionFromAlignment(horizontalAlign, verticalAlign, paddingX, paddingY);
-        positionX = position.x;
-        positionY = position.y;
-    }
-    else {
-        // Custom position
-        positionX = options.x || '(w-text_w)/2';
-        positionY = options.y || '(h-text_h)/2';
-    }
     // Determine output extension - detect actual format if input has .tmp extension
     let outputExt = path.extname(imagePath).toLowerCase();
     const knownImageExtensions = ['.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp', '.tiff'];
@@ -244,23 +197,67 @@ async function executeAddTextToImage(imagePath, text, options, itemIndex) {
         }
     }
     const outputPath = (0, utils_1.getTempFile)(outputExt);
-    // Escape single quotes in text
-    const escapedText = cleanedText.replace(/'/g, `''`);
-    // Map text alignment to FFmpeg format (L=left, C=center, R=right)
-    const textAlignMap = { left: 'L', center: 'C', right: 'R' };
-    const ffmpegTextAlign = textAlignMap[textAlign] || 'L';
-    // Build drawtext filter
-    let drawtext = `drawtext=fontfile=${fontPath}:text='${escapedText}':fontsize=${fontSize}:fontcolor=${fontColor}:x=${positionX}:y=${positionY}:text_align=${ffmpegTextAlign}:line_spacing=${lineSpacing}`;
-    // Add outline (border) if width > 0
-    if (outlineWidth > 0) {
-        drawtext += `:borderw=${outlineWidth}:bordercolor=${outlineColor}`;
+    // Split text into lines for multi-line center alignment support
+    const lines = cleanedText.split('\n').filter(line => line.length > 0);
+    // Calculate line height (fontSize + lineSpacing)
+    const lineHeight = fontSize + lineSpacing;
+    const totalTextHeight = lines.length * fontSize + (lines.length - 1) * lineSpacing;
+    // Build drawtext filters - one for each line
+    const drawtextFilters = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const escapedLine = line.replace(/'/g, `''`);
+        // Calculate X position based on horizontal alignment
+        let lineX;
+        switch (horizontalAlign) {
+            case 'left':
+                lineX = `${paddingX}`;
+                break;
+            case 'right':
+                lineX = `w-text_w-${paddingX}`;
+                break;
+            case 'center':
+            default:
+                lineX = '(w-text_w)/2';
+                break;
+        }
+        // Calculate Y position for this line
+        // Base Y from vertical alignment, then offset by line index
+        let lineY;
+        const verticalAlign = options.verticalAlign || 'middle';
+        const lineOffset = i * lineHeight;
+        switch (verticalAlign) {
+            case 'top':
+                lineY = `${paddingY + lineOffset}`;
+                break;
+            case 'bottom':
+                // Start from bottom, going up for total height, then down for each line
+                lineY = `h-${paddingY + totalTextHeight - lineOffset}`;
+                break;
+            case 'middle':
+            default:
+                // Center vertically, then offset each line
+                lineY = `(h-${totalTextHeight})/2+${lineOffset}`;
+                break;
+        }
+        // Build drawtext for this line
+        let drawtext = `drawtext=fontfile=${fontPath}:text='${escapedLine}':fontsize=${fontSize}:fontcolor=${fontColor}:x=${lineX}:y=${lineY}`;
+        // Add outline (border) if width > 0
+        if (outlineWidth > 0) {
+            drawtext += `:borderw=${outlineWidth}:bordercolor=${outlineColor}`;
+        }
+        // Add background box if enabled
+        if (enableBackground) {
+            drawtext += `:box=1:boxcolor=${backgroundColor}@${backgroundOpacity}:boxborderw=${boxPadding}`;
+        }
+        drawtextFilters.push(drawtext);
     }
-    // Add background box if enabled
-    if (enableBackground) {
-        drawtext += `:box=1:boxcolor=${backgroundColor}@${backgroundOpacity}:boxborderw=${boxPadding}`;
+    // If no lines (empty text), create a single empty filter to avoid errors
+    if (drawtextFilters.length === 0) {
+        drawtextFilters.push(`drawtext=fontfile=${fontPath}:text='':fontsize=${fontSize}:fontcolor=${fontColor}:x=0:y=0`);
     }
     const command = ffmpeg(imagePath)
-        .videoFilters(drawtext)
+        .videoFilters(drawtextFilters)
         .frames(1)
         .save(outputPath);
     try {

package/dist/nodes/MediaFX/utils.js

@@ -40,48 +40,74 @@ let ffmpegInitialized = false;
 function tryInitializeFfmpeg() {
     if (ffmpegInitialized)
         return true;
+    let ffmpegBinaryPath = null;
+    let ffprobeBinaryPath = null;
+    // Strategy 1: Try ffmpeg-static (recommended, includes FFmpeg 5.x+)
     try {
         // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const ffmpegInstaller = require('@ffmpeg-installer/ffmpeg');
+        const ffmpegStatic = require('ffmpeg-static');
+        if (ffmpegStatic && fs.existsSync(ffmpegStatic)) {
+            ffmpegBinaryPath = ffmpegStatic;
+            console.log(`FFmpeg found via ffmpeg-static: ${ffmpegStatic}`);
+        }
+    }
+    catch (e) {
+        console.warn('ffmpeg-static not available, trying fallback...');
+    }
+    // Strategy 2: Fallback to @ffmpeg-installer/ffmpeg
+    if (!ffmpegBinaryPath) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const ffmpegInstaller = require('@ffmpeg-installer/ffmpeg');
+            if (ffmpegInstaller.path && fs.existsSync(ffmpegInstaller.path)) {
+                ffmpegBinaryPath = ffmpegInstaller.path;
+                console.log(`FFmpeg found via @ffmpeg-installer: ${ffmpegInstaller.path}`);
+            }
+        }
+        catch (e) {
+            console.warn('@ffmpeg-installer/ffmpeg not available');
+        }
+    }
+    // Get ffprobe from @ffprobe-installer/ffprobe
+    try {
         // eslint-disable-next-line @typescript-eslint/no-require-imports
         const ffprobeInstaller = require('@ffprobe-installer/ffprobe');
-        const ffmpegInstallerPath = ffmpegInstaller.path;
-        const ffprobeInstallerPath = ffprobeInstaller.path;
-        if (ffmpegInstallerPath && fs.existsSync(ffmpegInstallerPath) && ffprobeInstallerPath && fs.existsSync(ffprobeInstallerPath)) {
-            // Set executable permissions dynamically
-            if (os.platform() !== 'win32') {
-                try {
-                    fs.chmodSync(ffmpegInstallerPath, '755');
-                    fs.chmodSync(ffprobeInstallerPath, '755');
-                    console.log('Dynamically set permissions for ffmpeg and ffprobe.');
-                }
-                catch (permissionError) {
-                    console.warn('Failed to set executable permissions dynamically:', permissionError);
-                }
-            }
-            ffmpeg.setFfmpegPath(ffmpegInstallerPath);
-            ffmpeg.setFfprobePath(ffprobeInstallerPath);
-            ffmpegPath = ffmpegInstallerPath;
-            ffmpegInitialized = true;
-            console.log(`FFmpeg initialized with @ffmpeg-installer: ${ffmpegInstallerPath}`);
-            console.log(`FFprobe initialized with @ffprobe-installer: ${ffprobeInstallerPath}`);
-            return true;
+        if (ffprobeInstaller.path && fs.existsSync(ffprobeInstaller.path)) {
+            ffprobeBinaryPath = ffprobeInstaller.path;
+            console.log(`FFprobe found via @ffprobe-installer: ${ffprobeInstaller.path}`);
         }
     }
-    catch (error) {
-        // This is the only strategy, so if it fails, we throw.
-        console.error('Failed to load FFmpeg/FFprobe from node_modules.', error);
-        throw new n8n_workflow_1.NodeOperationError(
-        // We can't use `this.getNode()` here as we are in a utility function.
-        // A generic error is sufficient.
-        { name: 'MediaFX', type: 'n8n-nodes-mediafx.mediaFX' }, 'Could not load the required FFmpeg executable from the package. ' +
-            'This might be due to a restricted execution environment or a broken installation. ' +
-            'Please check your n8n environment permissions. ' +
-            `Original error: ${error.message}`);
+    catch (e) {
+        console.warn('@ffprobe-installer/ffprobe not available');
+    }
+    // Validate and set paths
+    if (!ffmpegBinaryPath) {
+        console.error('FFmpeg binary not found in any package.');
+        throw new n8n_workflow_1.NodeOperationError({ name: 'MediaFX', type: 'n8n-nodes-mediafx.mediaFX' }, 'Could not find FFmpeg executable. Please ensure ffmpeg-static or @ffmpeg-installer/ffmpeg is properly installed.');
+    }
+    if (!ffprobeBinaryPath) {
+        console.error('FFprobe binary not found.');
+        throw new n8n_workflow_1.NodeOperationError({ name: 'MediaFX', type: 'n8n-nodes-mediafx.mediaFX' }, 'Could not find FFprobe executable. Please ensure @ffprobe-installer/ffprobe is properly installed.');
     }
-    // If we get here, something went wrong, but the catch didn't trigger.
-    console.error('FFmpeg binaries were not found in the expected package path.');
-    return false;
+    // Set executable permissions on non-Windows systems
+    if (os.platform() !== 'win32') {
+        try {
+            fs.chmodSync(ffmpegBinaryPath, '755');
+            fs.chmodSync(ffprobeBinaryPath, '755');
+            console.log('Set executable permissions for ffmpeg and ffprobe.');
+        }
+        catch (permissionError) {
+            console.warn('Failed to set executable permissions:', permissionError);
+        }
+    }
+    // Configure fluent-ffmpeg
+    ffmpeg.setFfmpegPath(ffmpegBinaryPath);
+    ffmpeg.setFfprobePath(ffprobeBinaryPath);
+    ffmpegPath = ffmpegBinaryPath;
+    ffmpegInitialized = true;
+    console.log(`FFmpeg initialized: ${ffmpegBinaryPath}`);
+    console.log(`FFprobe initialized: ${ffprobeBinaryPath}`);
+    return true;
 }
 // Try to initialize FFmpeg on module load
 tryInitializeFfmpeg();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lee-jisoo/n8n-nodes-mediafx",
-  "version": "1.6.26",
+  "version": "1.6.28",
   "description": "N8N custom nodes for video editing and media processing (Enhanced fork with Speed control and Subtitle fixes)",
   "license": "MIT",
   "author": {