@lee-jisoo/n8n-nodes-mediafx 1.6.0 → 1.6.1

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

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeSeparateAudio = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const ffmpeg = require("fluent-ffmpeg");
+const utils_1 = require("../utils");
+const fs = __importStar(require("fs-extra"));
+/**
+ * Separates audio from video, returning both a muted video and the extracted audio track.
+ *
+ * @param input - Path to the input video file
+ * @param videoFormat - Output format for the muted video (e.g., 'mp4', 'mov')
+ * @param audioFormat - Output format for the extracted audio (e.g., 'mp3', 'aac', 'wav')
+ * @param audioCodec - Audio codec to use (e.g., 'copy', 'libmp3lame', 'aac')
+ * @param audioBitrate - Audio bitrate (e.g., '192k', '320k')
+ * @param itemIndex - Current item index for error handling
+ * @returns Object containing paths to both the muted video and extracted audio
+ */
+async function executeSeparateAudio(input, videoFormat, audioFormat, audioCodec, audioBitrate, itemIndex) {
+    const mutedVideoPath = (0, utils_1.getTempFile)(`.${videoFormat}`);
+    const audioOutputPath = (0, utils_1.getTempFile)(`.${audioFormat}`);
+    let finalAudioCodec = audioCodec;
+    // If stream copy ('copy') is selected for a format that requires a specific
+    // codec (like mp3), we must override it to prevent an FFmpeg error.
+    if (finalAudioCodec === 'copy' && audioFormat === 'mp3') {
+        finalAudioCodec = 'libmp3lame';
+    }
+    try {
+        // Step 1: Create muted video (remove audio track)
+        const mutedVideoCommand = ffmpeg(input)
+            .output(mutedVideoPath)
+            .noAudio()
+            .videoCodec('copy'); // Copy video stream without re-encoding
+        await (0, utils_1.runFfmpeg)(mutedVideoCommand);
+        // Step 2: Extract audio track
+        const audioCommand = ffmpeg(input)
+            .output(audioOutputPath)
+            .noVideo()
+            .audioCodec(finalAudioCodec)
+            .audioBitrate(audioBitrate)
+            .outputOptions('-map', '0:a:0'); // Select first audio stream
+        await (0, utils_1.runFfmpeg)(audioCommand);
+        return {
+            videoPath: mutedVideoPath,
+            audioPath: audioOutputPath,
+        };
+    }
+    catch (error) {
+        // Clean up any created files on error
+        await fs.remove(mutedVideoPath).catch(() => { });
+        await fs.remove(audioOutputPath).catch(() => { });
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Error separating audio from video. Please ensure the source video contains both video and audio tracks. FFmpeg error: ${error.message}`, { itemIndex });
+    }
+}
+exports.executeSeparateAudio = executeSeparateAudio;

package/dist/nodes/MediaFX/operations/singleVideoFade.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+export declare function executeSingleVideoFade(this: IExecuteFunctions, input: string, effect: 'in' | 'out', startTime: number, duration: number, outputFormat: string, itemIndex: number): Promise<string>;

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

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeSingleVideoFade = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const ffmpeg = require("fluent-ffmpeg");
+const utils_1 = require("../utils");
+const fs = __importStar(require("fs-extra"));
+async function executeSingleVideoFade(input, 
+// effect is 'in' or 'out' from the UI options
+effect, startTime, duration, outputFormat, itemIndex) {
+    const outputPath = (0, utils_1.getTempFile)(`.${outputFormat}`);
+    const command = ffmpeg(input);
+    // Apply both video and audio fades for a consistent effect
+    const videoFade = `fade=type=${effect}:st=${startTime}:d=${duration}`;
+    const audioFade = `afade=type=${effect}:st=${startTime}:d=${duration}`;
+    command.videoFilters(videoFade).audioFilters(audioFade);
+    command.save(outputPath);
+    try {
+        await (0, utils_1.runFfmpeg)(command);
+        return outputPath;
+    }
+    catch (error) {
+        // Clean up output file if creation failed
+        await fs.remove(outputPath).catch(() => { });
+        // If the video has no audio, ffmpeg might throw an error for afade.
+        // We provide a more descriptive error message in that case.
+        const errorMessage = error.message;
+        let displayMessage = `Error applying fade effect. Please check the effect parameters (start time, duration).`;
+        if (errorMessage.includes('Cannot find a matching stream for unlabeled')) {
+            displayMessage = `Error applying audio fade: The source video may not have an audio track.`;
+        }
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `${displayMessage} FFmpeg error: ${errorMessage}`, {
+            itemIndex,
+        });
+    }
+}
+exports.executeSingleVideoFade = executeSingleVideoFade;

package/dist/nodes/MediaFX/operations/speed.d.ts

@@ -0,0 +1,12 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+/**
+ * Execute speed adjustment on a video.
+ *
+ * @param input - Path to the input video file
+ * @param speed - Speed multiplier (0.25 = 4x slower, 2.0 = 2x faster, etc.)
+ * @param adjustAudio - Whether to adjust audio speed as well (pitch will change)
+ * @param maintainPitch - Whether to maintain audio pitch when adjusting speed (requires rubberband filter)
+ * @param outputFormat - Output file format
+ * @param itemIndex - Index of the current item being processed
+ */
+export declare function executeSpeed(this: IExecuteFunctions, input: string, speed: number, adjustAudio: boolean, maintainPitch: boolean, outputFormat: string, itemIndex: number): Promise<string>;

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

@@ -0,0 +1,110 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeSpeed = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const ffmpeg = require("fluent-ffmpeg");
+const utils_1 = require("../utils");
+const fs = __importStar(require("fs-extra"));
+/**
+ * Execute speed adjustment on a video.
+ *
+ * @param input - Path to the input video file
+ * @param speed - Speed multiplier (0.25 = 4x slower, 2.0 = 2x faster, etc.)
+ * @param adjustAudio - Whether to adjust audio speed as well (pitch will change)
+ * @param maintainPitch - Whether to maintain audio pitch when adjusting speed (requires rubberband filter)
+ * @param outputFormat - Output file format
+ * @param itemIndex - Index of the current item being processed
+ */
+async function executeSpeed(input, speed, adjustAudio, maintainPitch, outputFormat, itemIndex) {
+    const outputPath = (0, utils_1.getTempFile)(`.${outputFormat}`);
+    // Validate speed value
+    if (speed <= 0) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Speed must be greater than 0', { itemIndex });
+    }
+    // FFmpeg uses PTS (Presentation Time Stamp) for video speed
+    // setpts=0.5*PTS means 2x faster (less time per frame)
+    // setpts=2*PTS means 2x slower (more time per frame)
+    const videoPtsFactor = 1 / speed;
+    const videoFilter = `setpts=${videoPtsFactor}*PTS`;
+    // For audio, atempo filter accepts values between 0.5 and 2.0
+    // For values outside this range, we need to chain multiple atempo filters
+    const buildAtempoFilter = (targetSpeed) => {
+        const filters = [];
+        let remaining = targetSpeed;
+        // atempo only accepts 0.5 to 2.0, so we chain multiple filters
+        while (remaining > 2.0) {
+            filters.push('atempo=2.0');
+            remaining /= 2.0;
+        }
+        while (remaining < 0.5) {
+            filters.push('atempo=0.5');
+            remaining /= 0.5;
+        }
+        filters.push(`atempo=${remaining}`);
+        return filters;
+    };
+    try {
+        let command = ffmpeg(input);
+        // Apply video speed filter
+        command = command.videoFilters([videoFilter]);
+        if (adjustAudio) {
+            if (maintainPitch) {
+                // Use rubberband filter to maintain pitch (requires libavfilter compiled with rubberband)
+                // Fallback to atempo if rubberband is not available
+                try {
+                    const audioFilter = `rubberband=tempo=${speed}`;
+                    command = command.audioFilters([audioFilter]);
+                }
+                catch {
+                    // Fallback to atempo (pitch will change slightly)
+                    const atempoFilters = buildAtempoFilter(speed);
+                    command = command.audioFilters(atempoFilters);
+                }
+            }
+            else {
+                // Use atempo filter (pitch will change proportionally)
+                const atempoFilters = buildAtempoFilter(speed);
+                command = command.audioFilters(atempoFilters);
+            }
+        }
+        else {
+            // Remove audio entirely when not adjusting
+            command = command.noAudio();
+        }
+        command = command
+            .videoCodec('libx264')
+            .audioCodec('aac')
+            .output(outputPath);
+        await (0, utils_1.runFfmpeg)(command);
+        return outputPath;
+    }
+    catch (error) {
+        // Clean up output file if creation failed
+        await fs.remove(outputPath).catch(() => { });
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Error adjusting video speed. FFmpeg error: ${error.message}`, { itemIndex });
+    }
+}
+exports.executeSpeed = executeSpeed;

package/dist/nodes/MediaFX/operations/stampImage.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions, IDataObject } from 'n8n-workflow';
+export declare function executeStampImage(this: IExecuteFunctions, videoPath: string, imagePath: string, options: IDataObject, itemIndex: number): Promise<string>;

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

@@ -0,0 +1,146 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeStampImage = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const path = __importStar(require("path"));
+const ffmpeg = require("fluent-ffmpeg");
+const utils_1 = require("../utils");
+const fs = __importStar(require("fs-extra"));
+async function executeStampImage(videoPath, imagePath, options, itemIndex) {
+    var _a;
+    const outputPath = (0, utils_1.getTempFile)(path.extname(videoPath));
+    // Basic stamp options
+    const width = options.width || 150;
+    const height = options.height || -1;
+    const x = options.x || '10';
+    const y = options.y || '10';
+    const rotationDegrees = options.rotation || 0;
+    const opacity = (_a = options.opacity) !== null && _a !== void 0 ? _a : 1.0;
+    // Time control options
+    const enableTimeControl = options.enableTimeControl;
+    const startTime = options.startTime || 0;
+    const endTime = options.endTime || 5;
+    try {
+        // Get video duration for calculations
+        // const videoDuration = await getDuration(videoPath);
+        // console.log('=== STAMP IMAGE DEBUG ===');
+        // console.log('Video path:', videoPath);
+        // console.log('Image path:', imagePath);
+        // console.log('Video duration:', videoDuration);
+        // console.log('Stamp options:', {
+        // 	width, height, x, y, rotationDegrees, opacity,
+        // 	enableTimeControl, startTime, endTime
+        // });
+        // Start with the simplest possible filter
+        let complexFilter = '';
+        // Check if we need any processing
+        const needsScaling = width !== -1 || height !== -1;
+        const needsRotation = rotationDegrees !== 0;
+        const needsOpacity = opacity < 1.0;
+        const needsProcessing = needsScaling || needsRotation || needsOpacity;
+        if (!needsProcessing && !enableTimeControl) {
+            // Simplest case: direct overlay
+            complexFilter = '[0:v][1:v]overlay=x=' + x + ':y=' + y;
+        }
+        else if (!enableTimeControl) {
+            // Process image but no time control
+            let imageFilter = '[1:v]';
+            if (needsScaling) {
+                imageFilter += 'scale=' + width + ':' + height;
+            }
+            if (needsRotation) {
+                if (!needsScaling) {
+                    imageFilter += 'rotate=' + (rotationDegrees * Math.PI / 180) + ':fillcolor=none';
+                }
+                else {
+                    imageFilter += ',rotate=' + (rotationDegrees * Math.PI / 180) + ':fillcolor=none';
+                }
+            }
+            if (needsOpacity) {
+                if (!needsScaling && !needsRotation) {
+                    imageFilter += 'colorchannelmixer=aa=' + opacity;
+                }
+                else {
+                    imageFilter += ',colorchannelmixer=aa=' + opacity;
+                }
+            }
+            imageFilter += '[processed]';
+            complexFilter = imageFilter + ';[0:v][processed]overlay=x=' + x + ':y=' + y;
+        }
+        else {
+            // With time control
+            let imageFilter = '[1:v]';
+            if (needsScaling) {
+                imageFilter += 'scale=' + width + ':' + height;
+            }
+            if (needsRotation) {
+                if (!needsScaling) {
+                    imageFilter += 'rotate=' + (rotationDegrees * Math.PI / 180) + ':fillcolor=none';
+                }
+                else {
+                    imageFilter += ',rotate=' + (rotationDegrees * Math.PI / 180) + ':fillcolor=none';
+                }
+            }
+            if (needsOpacity) {
+                if (!needsScaling && !needsRotation) {
+                    imageFilter += 'colorchannelmixer=aa=' + opacity;
+                }
+                else {
+                    imageFilter += ',colorchannelmixer=aa=' + opacity;
+                }
+            }
+            if (needsProcessing) {
+                imageFilter += '[processed]';
+                complexFilter = imageFilter + ';[0:v][processed]overlay=x=' + x + ':y=' + y;
+            }
+            else {
+                complexFilter = '[0:v][1:v]overlay=x=' + x + ':y=' + y;
+            }
+            // Add time control
+            if (enableTimeControl) {
+                complexFilter += ':enable=\'between(t,' + startTime + ',' + endTime + ')\'';
+            }
+        }
+        console.log('Generated FFmpeg filter:', complexFilter);
+        console.log('========================');
+        const command = ffmpeg()
+            .input(videoPath)
+            .input(imagePath)
+            .complexFilter(complexFilter)
+            .output(outputPath);
+        await (0, utils_1.runFfmpeg)(command);
+        return outputPath;
+    }
+    catch (error) {
+        // Clean up output file if creation failed
+        await fs.remove(outputPath).catch(() => { });
+        console.error('=== STAMP IMAGE ERROR ===');
+        console.error('Error details:', error);
+        console.error('========================');
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to stamp image: ${error instanceof Error ? error.message : 'Unknown error'}`, { itemIndex });
+    }
+}
+exports.executeStampImage = executeStampImage;

package/dist/nodes/MediaFX/operations/trim.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+export declare function executeTrim(this: IExecuteFunctions, input: string, from: number, to: number, outputFormat: string, itemIndex: number): Promise<string>;

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

@@ -0,0 +1,49 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeTrim = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const ffmpeg = require("fluent-ffmpeg");
+const utils_1 = require("../utils");
+const fs = __importStar(require("fs-extra"));
+async function executeTrim(input, from, to, outputFormat, itemIndex) {
+    const outputPath = (0, utils_1.getTempFile)(`.${outputFormat}`);
+    const command = ffmpeg(input)
+        .setStartTime(from)
+        .setDuration(to - from)
+        .output(outputPath)
+        .videoCodec('libx264')
+        .audioCodec('aac');
+    try {
+        await (0, utils_1.runFfmpeg)(command);
+        return outputPath;
+    }
+    catch (error) {
+        // Clean up output file if creation failed
+        await fs.remove(outputPath).catch(() => { });
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Error trimming video. Please check that start and end times are valid and within the video's duration. FFmpeg error: ${error.message}`, { itemIndex });
+    }
+}
+exports.executeTrim = executeTrim;

package/dist/nodes/MediaFX/properties/audio.properties.d.ts

@@ -0,0 +1,2 @@
+import { INodeProperties } from 'n8n-workflow';
+export declare const audioProperties: INodeProperties[];