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

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

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeMixAudio = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const utils_1 = require("../utils");
+const ffmpeg = require("fluent-ffmpeg");
+async function executeMixAudio(videoPath, audioPath, videoVolume, audioVolume, matchLength, advancedMixing, itemIndex) {
+    // Verify FFmpeg is available before proceeding
+    try {
+        (0, utils_1.verifyFfmpegAvailability)();
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `FFmpeg is not available: ${error.message}`, { itemIndex });
+    }
+    const outputPath = (0, utils_1.getTempFile)('.mp4');
+    const { enablePartialMix = false, startTime = 0, duration, loop = false, enableFadeIn = false, fadeInDuration = 1, enableFadeOut = false, fadeOutDuration = 1, } = advancedMixing;
+    // Check if both inputs have audio
+    const videoHasAudio = await (0, utils_1.fileHasAudio)(videoPath);
+    const audioFileHasAudio = await (0, utils_1.fileHasAudio)(audioPath);
+    // If the "audio" file doesn't have audio, throw an error
+    if (!audioFileHasAudio) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'The secondary audio source does not contain any audio stream', { itemIndex });
+    }
+    // If video doesn't have audio, we'll create a silent audio track for it
+    let actualVideoPath = videoPath;
+    let videoCleanup = null;
+    if (!videoHasAudio) {
+        const videoDuration = await (0, utils_1.getDuration)(videoPath);
+        const { filePath: silentAudioPath, cleanup } = await (0, utils_1.createSilentAudio)(videoDuration);
+        videoCleanup = cleanup;
+        // Create a temporary video with silent audio
+        const tempVideoWithAudio = (0, utils_1.getTempFile)('.mp4');
+        const addSilentCommand = ffmpeg()
+            .input(videoPath)
+            .input(silentAudioPath)
+            .outputOptions(['-map', '0:v', '-map', '1:a', '-c:v', 'copy', '-shortest'])
+            .save(tempVideoWithAudio);
+        await (0, utils_1.runFfmpeg)(addSilentCommand);
+        await cleanup(); // Clean up the silent audio file
+        actualVideoPath = tempVideoWithAudio;
+        videoCleanup = () => require('fs-extra').remove(tempVideoWithAudio);
+    }
+    const command = ffmpeg().input(actualVideoPath).input(audioPath);
+    if (enablePartialMix) {
+        // Get audio duration to determine processing strategy
+        const audioDuration = await (0, utils_1.getDuration)(audioPath);
+        // If duration is not provided (null/undefined), use audio duration
+        const actualDuration = duration || audioDuration;
+        let audioProcessingChain = '[1:a]';
+        // Step 1: Handle looping if needed
+        if (loop && audioDuration < actualDuration) {
+            audioProcessingChain += 'aloop=loop=-1:size=2e9,';
+        }
+        // Step 2: Trim to duration
+        if (loop && audioDuration < actualDuration || audioDuration >= actualDuration) {
+            audioProcessingChain += `atrim=duration=${actualDuration},`;
+        }
+        // Step 3: Reset timestamps
+        audioProcessingChain += 'asetpts=PTS-STARTPTS,';
+        // Step 4: Apply fade effects
+        const fadeFilters = [];
+        if (enableFadeIn) {
+            fadeFilters.push(`afade=t=in:st=0:d=${fadeInDuration}`);
+        }
+        if (enableFadeOut) {
+            const fadeOutStart = Math.max(0, actualDuration - fadeOutDuration);
+            fadeFilters.push(`afade=t=out:st=${fadeOutStart}:d=${fadeOutDuration}`);
+        }
+        if (fadeFilters.length > 0) {
+            audioProcessingChain += fadeFilters.join(',') + ',';
+        }
+        // Step 5: Set volume and add delay
+        audioProcessingChain += `volume=${audioVolume},adelay=${startTime * 1000}|${startTime * 1000}[overlay_audio]`;
+        const filterComplex = audioProcessingChain + ';' +
+            `[0:a]volume=${videoVolume}[main_audio];` +
+            `[main_audio][overlay_audio]amix=inputs=2:duration=first:dropout_transition=0[mixed_audio]`;
+        command
+            .complexFilter(filterComplex)
+            .outputOptions(['-map', '0:v', '-map', '[mixed_audio]', '-c:v copy']);
+    }
+    else {
+        // Standard full audio mix with fade effects
+        let audioProcessingChain = '[1:a]';
+        // Calculate the effective duration based on matchLength
+        const videoDuration = await (0, utils_1.getDuration)(actualVideoPath);
+        const audioDuration = await (0, utils_1.getDuration)(audioPath);
+        let effectiveDuration;
+        switch (matchLength) {
+            case 'shortest':
+                effectiveDuration = Math.min(videoDuration, audioDuration);
+                break;
+            case 'longest':
+                effectiveDuration = Math.max(videoDuration, audioDuration);
+                break;
+            case 'first':
+            default:
+                effectiveDuration = videoDuration;
+                break;
+        }
+        // Apply fade effects if enabled
+        const fadeFilters = [];
+        if (enableFadeIn) {
+            fadeFilters.push(`afade=t=in:st=0:d=${fadeInDuration}`);
+        }
+        if (enableFadeOut) {
+            // Calculate fade out start based on effective duration, not original audio duration
+            const fadeOutStart = Math.max(0, effectiveDuration - fadeOutDuration);
+            fadeFilters.push(`afade=t=out:st=${fadeOutStart}:d=${fadeOutDuration}`);
+        }
+        if (fadeFilters.length > 0) {
+            audioProcessingChain += fadeFilters.join(',') + ',';
+        }
+        // Apply volume and create labeled output
+        audioProcessingChain += `volume=${audioVolume}[a1]`;
+        const filterComplex = audioProcessingChain + ';' +
+            `[0:a]volume=${videoVolume}[a0];` +
+            `[a0][a1]amix=inputs=2:duration=${matchLength}[a]`;
+        command
+            .complexFilter(filterComplex)
+            .outputOptions(['-map', '0:v', '-map', '[a]', '-c:v copy']);
+    }
+    command.save(outputPath);
+    try {
+        await (0, utils_1.runFfmpeg)(command);
+        // Clean up temporary video file if we created one
+        if (videoCleanup) {
+            await videoCleanup();
+        }
+        return outputPath;
+    }
+    catch (error) {
+        // Clean up output file if creation failed
+        await require('fs-extra').remove(outputPath).catch(() => { });
+        // Clean up temporary video file if we created one
+        if (videoCleanup) {
+            await videoCleanup().catch(() => { });
+        }
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Error mixing audio: ${error.message}`, { itemIndex });
+    }
+}
+exports.executeMixAudio = executeMixAudio;

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

@@ -0,0 +1,2 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+export declare function executeMultiVideoTransition(this: IExecuteFunctions, inputs: string[], transition: string, duration: number, outputFormat: string, itemIndex: number): Promise<string>;

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

@@ -0,0 +1,245 @@
+"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.executeMultiVideoTransition = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const ffmpeg = require("fluent-ffmpeg");
+const utils_1 = require("../utils");
+const ffmpegVersion_1 = require("../utils/ffmpegVersion");
+const fs = __importStar(require("fs-extra"));
+async function executeMultiVideoTransition(inputs, transition, duration, outputFormat, itemIndex) {
+    if (inputs.length < 2) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Transition (Apply) operation requires at least two source videos.', { itemIndex });
+    }
+    // Check if the requested transition is supported
+    const transitionSupport = await (0, ffmpegVersion_1.checkTransitionSupport)(transition);
+    let effectiveTransition = transition;
+    if (!transitionSupport.supported) {
+        if (transitionSupport.alternative) {
+            effectiveTransition = transitionSupport.alternative;
+            console.warn(transitionSupport.message);
+        }
+        else {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), transitionSupport.message || 'Unsupported transition effect', { itemIndex });
+        }
+    }
+    const outputPath = (0, utils_1.getTempFile)(`.${outputFormat}`);
+    const command = ffmpeg();
+    inputs.forEach((input) => command.addInput(input));
+    const durations = await Promise.all(inputs.map((input) => (0, utils_1.getDuration)(input)));
+    if (durations.some((d) => d === null)) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Could not get duration of one or more videos.', {
+            itemIndex,
+        });
+    }
+    // Check if all input videos have audio
+    const audioChecks = await Promise.all(inputs.map((input) => (0, utils_1.fileHasAudio)(input)));
+    const allHaveAudio = audioChecks.every((hasAudio) => hasAudio);
+    const someHaveAudio = audioChecks.some((hasAudio) => hasAudio);
+    // Warn if only some videos have audio
+    if (someHaveAudio && !allHaveAudio) {
+        console.warn('Warning: Not all input videos have audio tracks. Audio will be excluded from the output.');
+    }
+    // Get video dimensions using ffprobe to determine common resolution
+    const getDimensions = async (inputPath) => {
+        return new Promise((resolve, reject) => {
+            ffmpeg.ffprobe(inputPath, (err, metadata) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                const videoStream = metadata.streams.find(s => s.codec_type === 'video');
+                if (!videoStream || !videoStream.width || !videoStream.height) {
+                    reject(new Error('Could not get video dimensions'));
+                    return;
+                }
+                resolve({ width: videoStream.width, height: videoStream.height });
+            });
+        });
+    };
+    // Get dimensions of all input videos
+    const dimensions = await Promise.all(inputs.map(input => getDimensions(input)));
+    // Find the maximum dimensions to use as target resolution
+    const targetWidth = Math.max(...dimensions.map(d => d.width));
+    const targetHeight = Math.max(...dimensions.map(d => d.height));
+    console.log(`[MediaFX] Target resolution for transition: ${targetWidth}x${targetHeight}`);
+    // Initialize video streams with scaling to common resolution
+    const filterGraph = inputs.map((_, i) => {
+        const dim = dimensions[i];
+        if (dim.width !== targetWidth || dim.height !== targetHeight) {
+            // Scale and pad to maintain aspect ratio
+            return `[${i}:v]scale=${targetWidth}:${targetHeight}:force_original_aspect_ratio=decrease,pad=${targetWidth}:${targetHeight}:(ow-iw)/2:(oh-ih)/2:black,settb=AVTB[v${i}]`;
+        }
+        else {
+            // No scaling needed
+            return `[${i}:v]settb=AVTB[v${i}]`;
+        }
+    });
+    // Initialize audio streams only if audio exists
+    if (allHaveAudio) {
+        inputs.forEach((_, i) => {
+            filterGraph.push(`[${i}:a]aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo[a${i}]`);
+        });
+    }
+    let lastVideoOut = 'v0';
+    let lastAudioOut = 'a0';
+    let cumulativeDuration = durations[0];
+    // Use different filter strategies based on transition type
+    if (effectiveTransition === 'fade' || effectiveTransition === 'fadeblack' || effectiveTransition === 'fadewhite') {
+        // Fallback implementation for fade transitions without xfade
+        // Simply concatenate videos with fade effects applied to each segment
+        const videoSegments = [];
+        const audioSegments = [];
+        for (let i = 0; i < inputs.length; i++) {
+            const videoDuration = durations[i];
+            const isFirst = i === 0;
+            const isLast = i === inputs.length - 1;
+            const videoSegment = `vseg${i}`;
+            if (isFirst && isLast) {
+                // Only one video - no transitions needed
+                videoSegments.push(`v${i}`);
+            }
+            else if (isFirst) {
+                // First video: fade out at the end
+                const fadeOutStart = videoDuration - duration;
+                filterGraph.push(`[v${i}]fade=t=out:st=${fadeOutStart}:d=${duration}[${videoSegment}]`);
+                videoSegments.push(videoSegment);
+            }
+            else if (isLast) {
+                // Last video: fade in at the beginning
+                filterGraph.push(`[v${i}]fade=t=in:st=0:d=${duration}[${videoSegment}]`);
+                videoSegments.push(videoSegment);
+            }
+            else {
+                // Middle videos: fade in at start, fade out at end
+                const fadeOutStart = videoDuration - duration;
+                filterGraph.push(`[v${i}]fade=t=in:st=0:d=${duration},fade=t=out:st=${fadeOutStart}:d=${duration}[${videoSegment}]`);
+                videoSegments.push(videoSegment);
+            }
+        }
+        // Concatenate all video segments
+        if (videoSegments.length === 1) {
+            lastVideoOut = videoSegments[0];
+        }
+        else {
+            lastVideoOut = 'vconcat';
+            const concatFilter = videoSegments.map(seg => `[${seg}]`).join('') +
+                `concat=n=${videoSegments.length}:v=1:a=0[${lastVideoOut}]`;
+            filterGraph.push(concatFilter);
+        }
+        // Handle audio if it exists
+        if (allHaveAudio) {
+            for (let i = 0; i < inputs.length; i++) {
+                const audioDuration = durations[i];
+                const isFirst = i === 0;
+                const isLast = i === inputs.length - 1;
+                const audioSegment = `aseg${i}`;
+                if (isFirst && isLast) {
+                    audioSegments.push(`a${i}`);
+                }
+                else if (isFirst) {
+                    const fadeOutStart = audioDuration - duration;
+                    filterGraph.push(`[a${i}]afade=t=out:st=${fadeOutStart}:d=${duration}[${audioSegment}]`);
+                    audioSegments.push(audioSegment);
+                }
+                else if (isLast) {
+                    filterGraph.push(`[a${i}]afade=t=in:st=0:d=${duration}[${audioSegment}]`);
+                    audioSegments.push(audioSegment);
+                }
+                else {
+                    const fadeOutStart = audioDuration - duration;
+                    filterGraph.push(`[a${i}]afade=t=in:st=0:d=${duration},afade=t=out:st=${fadeOutStart}:d=${duration}[${audioSegment}]`);
+                    audioSegments.push(audioSegment);
+                }
+            }
+            // Concatenate all audio segments
+            if (audioSegments.length === 1) {
+                lastAudioOut = audioSegments[0];
+            }
+            else {
+                lastAudioOut = 'aconcat';
+                const audioConcatFilter = audioSegments.map(seg => `[${seg}]`).join('') +
+                    `concat=n=${audioSegments.length}:v=0:a=1[${lastAudioOut}]`;
+                filterGraph.push(audioConcatFilter);
+            }
+        }
+    }
+    else {
+        // Use xfade for supported transitions
+        for (let i = 1; i < inputs.length; i++) {
+            const nextVideo = `v${i}`;
+            const nextAudio = `a${i}`;
+            const currentVideoOut = `vout${i}`;
+            const currentAudioOut = `aout${i}`;
+            const offset = cumulativeDuration - duration;
+            filterGraph.push(`[${lastVideoOut}][${nextVideo}]xfade=transition=${effectiveTransition}:duration=${duration}:offset=${offset}[${currentVideoOut}]`);
+            if (allHaveAudio) {
+                filterGraph.push(`[${lastAudioOut}][${nextAudio}]acrossfade=d=${duration}[${currentAudioOut}]`);
+            }
+            lastVideoOut = currentVideoOut;
+            if (allHaveAudio) {
+                lastAudioOut = currentAudioOut;
+            }
+            cumulativeDuration += durations[i] - duration;
+        }
+    }
+    // Build output options based on available streams
+    const outputOptions = ['-map', `[${lastVideoOut}]`];
+    if (allHaveAudio) {
+        outputOptions.push('-map', `[${lastAudioOut}]`);
+    }
+    command
+        .complexFilter(filterGraph)
+        .outputOptions(outputOptions)
+        .videoCodec('libx264');
+    if (allHaveAudio) {
+        command.audioCodec('aac');
+    }
+    command.save(outputPath);
+    try {
+        await (0, utils_1.runFfmpeg)(command);
+        // If we used a fallback transition, add a note to the result
+        if (effectiveTransition !== transition && transitionSupport.message) {
+            console.log(`Transition fallback: ${transitionSupport.message}`);
+        }
+        return outputPath;
+    }
+    catch (error) {
+        // Clean up output file if creation failed
+        await fs.remove(outputPath).catch(() => { });
+        const errorMessage = error.message;
+        let helpfulMessage = 'Error applying transition.';
+        // Check for specific error patterns
+        if (errorMessage.includes('No such filter: \'xfade\'')) {
+            helpfulMessage = `Your FFmpeg version doesn't support the 'xfade' filter (requires FFmpeg 4.3+). ` +
+                `The transition '${transition}' requires xfade. Please upgrade FFmpeg or use basic transitions like 'fade'.`;
+        }
+        else if (errorMessage.includes('Invalid argument')) {
+            helpfulMessage = `Invalid transition parameters. The '${transition}' effect may not be supported by your FFmpeg version.`;
+        }
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `${helpfulMessage} FFmpeg error: ${errorMessage}`, { itemIndex });
+    }
+}
+exports.executeMultiVideoTransition = executeMultiVideoTransition;

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

@@ -0,0 +1,16 @@
+import { IExecuteFunctions, IDataObject } from 'n8n-workflow';
+export interface OverlayVideoOptions {
+    x: string | number;
+    y: string | number;
+    width: number;
+    height: number;
+    opacity: number;
+    enableTimeControl: boolean;
+    startTime: number;
+    endTime: number;
+    blendMode: string;
+    audioHandling: 'main' | 'overlay' | 'mix' | 'none';
+    mainVolume: number;
+    overlayVolume: number;
+}
+export declare function executeOverlayVideo(this: IExecuteFunctions, mainVideoPath: string, overlayVideoPath: string, options: IDataObject, itemIndex: number): Promise<string>;

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

@@ -0,0 +1,240 @@
+"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.executeOverlayVideo = 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 executeOverlayVideo(mainVideoPath, overlayVideoPath, options, itemIndex) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;
+    // Verify FFmpeg is available before proceeding
+    try {
+        (0, utils_1.verifyFfmpegAvailability)();
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `FFmpeg is not available: ${error.message}`, { itemIndex });
+    }
+    // Extract output format from options (default to mp4)
+    const outputFormat = options.outputFormat || 'mp4';
+    const outputPath = (0, utils_1.getTempFile)(`.${outputFormat}`);
+    // Extract options with defaults
+    // Position options
+    const positionMode = (_a = options.positionMode) !== null && _a !== void 0 ? _a : 'alignment';
+    const horizontalAlign = (_b = options.horizontalAlign) !== null && _b !== void 0 ? _b : 'center';
+    const verticalAlign = (_c = options.verticalAlign) !== null && _c !== void 0 ? _c : 'middle';
+    const paddingX = (_d = options.paddingX) !== null && _d !== void 0 ? _d : 0;
+    const paddingY = (_e = options.paddingY) !== null && _e !== void 0 ? _e : 0;
+    const customX = (_f = options.x) !== null && _f !== void 0 ? _f : '0';
+    const customY = (_g = options.y) !== null && _g !== void 0 ? _g : '0';
+    // Size options
+    const sizeMode = (_h = options.sizeMode) !== null && _h !== void 0 ? _h : 'percentage';
+    const widthPercent = (_j = options.widthPercent) !== null && _j !== void 0 ? _j : 50;
+    const heightMode = (_k = options.heightMode) !== null && _k !== void 0 ? _k : 'auto';
+    const heightPercent = (_l = options.heightPercent) !== null && _l !== void 0 ? _l : 50;
+    const widthPixels = (_m = options.widthPixels) !== null && _m !== void 0 ? _m : -1;
+    const heightPixels = (_o = options.heightPixels) !== null && _o !== void 0 ? _o : -1;
+    const opacity = (_p = options.opacity) !== null && _p !== void 0 ? _p : 1.0;
+    const enableTimeControl = (_q = options.enableTimeControl) !== null && _q !== void 0 ? _q : false;
+    const startTime = (_r = options.startTime) !== null && _r !== void 0 ? _r : 0;
+    const endTime = (_s = options.endTime) !== null && _s !== void 0 ? _s : 0;
+    const blendMode = (_t = options.blendMode) !== null && _t !== void 0 ? _t : 'normal';
+    const audioHandling = (_u = options.audioHandling) !== null && _u !== void 0 ? _u : 'main';
+    const mainVolume = (_v = options.mainVolume) !== null && _v !== void 0 ? _v : 1.0;
+    const overlayVolume = (_w = options.overlayVolume) !== null && _w !== void 0 ? _w : 1.0;
+    try {
+        // Get durations for calculations
+        const mainDuration = await (0, utils_1.getDuration)(mainVideoPath);
+        const overlayDuration = await (0, utils_1.getDuration)(overlayVideoPath);
+        // Get main video resolution for percentage calculations
+        const mainVideoInfo = await (0, utils_1.getVideoStreamInfo)(mainVideoPath);
+        const mainWidth = (mainVideoInfo === null || mainVideoInfo === void 0 ? void 0 : mainVideoInfo.width) || 1920;
+        const mainHeight = (mainVideoInfo === null || mainVideoInfo === void 0 ? void 0 : mainVideoInfo.height) || 1080;
+        // Calculate actual overlay dimensions based on size mode
+        let scaleWidth = -1;
+        let scaleHeight = -1;
+        if (sizeMode === 'percentage') {
+            // Calculate width as percentage of main video
+            scaleWidth = Math.round(mainWidth * (widthPercent / 100));
+            if (heightMode === 'auto') {
+                // Keep aspect ratio - use -1 for FFmpeg to auto-calculate
+                scaleHeight = -1;
+            }
+            else {
+                // Calculate height as percentage of main video
+                scaleHeight = Math.round(mainHeight * (heightPercent / 100));
+            }
+        }
+        else if (sizeMode === 'pixels') {
+            scaleWidth = widthPixels;
+            scaleHeight = heightPixels;
+        }
+        // If sizeMode === 'original', leave both as -1 (no scaling)
+        const needsScaling = sizeMode !== 'original';
+        // Calculate position based on position mode
+        let posX;
+        let posY;
+        if (positionMode === 'alignment') {
+            // Use FFmpeg expressions for alignment
+            // overlay_w and overlay_h refer to the scaled overlay dimensions
+            switch (horizontalAlign) {
+                case 'left':
+                    posX = String(paddingX);
+                    break;
+                case 'center':
+                    posX = `(main_w-overlay_w)/2`;
+                    break;
+                case 'right':
+                    posX = `main_w-overlay_w-${paddingX}`;
+                    break;
+                default:
+                    posX = String(paddingX);
+            }
+            switch (verticalAlign) {
+                case 'top':
+                    posY = String(paddingY);
+                    break;
+                case 'middle':
+                    posY = `(main_h-overlay_h)/2`;
+                    break;
+                case 'bottom':
+                    posY = `main_h-overlay_h-${paddingY}`;
+                    break;
+                default:
+                    posY = String(paddingY);
+            }
+            // Add padding offset for center alignment
+            if (horizontalAlign === 'center' && paddingX !== 0) {
+                posX = `(main_w-overlay_w)/2+${paddingX}`;
+            }
+            if (verticalAlign === 'middle' && paddingY !== 0) {
+                posY = `(main_h-overlay_h)/2+${paddingY}`;
+            }
+        }
+        else {
+            // Custom coordinates mode - use provided x, y values
+            posX = String(customX);
+            posY = String(customY);
+        }
+        // Calculate actual end time
+        const actualEndTime = enableTimeControl
+            ? (endTime > 0 ? endTime : mainDuration)
+            : mainDuration;
+        // Build the video filter chain
+        let videoFilterChain = '';
+        // Process overlay video (scale if needed)
+        const needsOpacity = opacity < 1.0;
+        let overlayProcessing = '[1:v]';
+        if (needsScaling) {
+            overlayProcessing += `scale=${scaleWidth}:${scaleHeight}`;
+        }
+        if (needsOpacity) {
+            if (needsScaling) {
+                overlayProcessing += ',';
+            }
+            overlayProcessing += `colorchannelmixer=aa=${opacity}`;
+        }
+        // Apply blend mode filter if not normal
+        if (blendMode !== 'normal' && blendMode !== 'over') {
+            if (needsScaling || needsOpacity) {
+                overlayProcessing += ',';
+            }
+            // For blend modes, we'll use the blend filter differently
+        }
+        if (needsScaling || needsOpacity) {
+            overlayProcessing += '[ovr]';
+            videoFilterChain = overlayProcessing + ';';
+            videoFilterChain += '[0:v][ovr]';
+        }
+        else {
+            videoFilterChain = '[0:v][1:v]';
+        }
+        // Build overlay filter with position
+        // eof_action=pass: continue showing main video after overlay ends
+        // repeatlast=0: don't repeat the last frame of overlay
+        videoFilterChain += `overlay=x=${posX}:y=${posY}:eof_action=pass:repeatlast=0`;
+        // Add time control if enabled
+        if (enableTimeControl) {
+            videoFilterChain += `:enable='between(t,${startTime},${actualEndTime})'`;
+        }
+        videoFilterChain += '[outv]';
+        // Build audio filter chain based on audio handling option
+        let audioFilterChain = '';
+        let outputMaps = ['-map', '[outv]'];
+        switch (audioHandling) {
+            case 'main':
+                // Use only main video's audio
+                outputMaps.push('-map', '0:a?');
+                break;
+            case 'overlay':
+                // Use only overlay video's audio
+                outputMaps.push('-map', '1:a?');
+                break;
+            case 'mix':
+                // Mix both audio tracks (use longest duration)
+                audioFilterChain = `;[0:a]volume=${mainVolume}[a0];[1:a]volume=${overlayVolume}[a1];[a0][a1]amix=inputs=2:duration=longest[outa]`;
+                outputMaps.push('-map', '[outa]');
+                break;
+            case 'none':
+                // No audio output
+                break;
+            default:
+                outputMaps.push('-map', '0:a?');
+        }
+        const fullFilterComplex = videoFilterChain + audioFilterChain;
+        console.log('=== OVERLAY VIDEO DEBUG ===');
+        console.log('Main video:', mainVideoPath);
+        console.log('Overlay video:', overlayVideoPath);
+        console.log('Main duration:', mainDuration);
+        console.log('Overlay duration:', overlayDuration);
+        console.log('Main resolution:', { mainWidth, mainHeight });
+        console.log('Position mode:', positionMode);
+        console.log('Calculated position:', { posX, posY });
+        console.log('Size mode:', sizeMode);
+        console.log('Calculated scale:', { scaleWidth, scaleHeight, needsScaling });
+        console.log('Options:', { opacity, enableTimeControl, startTime, actualEndTime, blendMode, audioHandling });
+        console.log('Filter complex:', fullFilterComplex);
+        console.log('Output maps:', outputMaps);
+        console.log('===========================');
+        const command = ffmpeg()
+            .input(mainVideoPath)
+            .input(overlayVideoPath)
+            .complexFilter(fullFilterComplex)
+            .outputOptions(outputMaps)
+            .outputOptions(['-c:v', 'libx264', '-preset', 'fast', '-crf', '23'])
+            .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('=== OVERLAY VIDEO ERROR ===');
+        console.error('Error details:', error);
+        console.error('===========================');
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to overlay video: ${error instanceof Error ? error.message : 'Unknown error'}`, { itemIndex });
+    }
+}
+exports.executeOverlayVideo = executeOverlayVideo;

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

@@ -0,0 +1,17 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+export interface SeparateAudioResult {
+    videoPath: string;
+    audioPath: string;
+}
+/**
+ * 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
+ */
+export declare function executeSeparateAudio(this: IExecuteFunctions, input: string, videoFormat: string, audioFormat: string, audioCodec: string, audioBitrate: string, itemIndex: number): Promise<SeparateAudioResult>;