n8n-nodes-ffmpeg-bigboss 1.0.0

package/README.md

@@ -0,0 +1,55 @@
+# n8n-nodes-ffmpeg-bigboss
+
+[![npm version](https://badge.fury.io/js/n8n-nodes-ffmpeg-bigboss.svg)](https://badge.fury.io/js/n8n-nodes-ffmpeg-bigboss)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**BigBoss** audiovisual processing node for n8n. Refactored from the ground up to provide reliable, production-ready FFmpeg capabilities.
+
+## 🚀 Key Features
+
+- **BigBoss Reliability**: Fixed known muxing issues with explicit stream mapping (`-map 0:v -map 1:a`).
+- **Dual Input Modes**:
+  - **Binary**: Process data directly from n8n workflows.
+  - **File Path**: Handle large files directly from disk without memory overhead.
+- **Two Operation Modes**:
+  - **Simple**: Easy presets for quick tasks.
+  - **BigBoss**: Full granular control over Codecs, CRF, Presets, and Custom Arguments.
+
+## 📦 Operations
+
+1. **Convert / Transcode**: Change format, codec, and resolution.
+2. **Compress**: Optimize file size with CRF and Presets.
+3. **Extract Audio**: Rip audio from video.
+4. **Merge Video & Audio**: Combine video and audio files with perfect synchronization.
+5. **Get Metadata**: Analyze media streams using `ffprobe`.
+6. **Custom Command**: Run any raw FFmpeg command.
+
+## 🛠️ Usage
+
+### Merge Video & Audio (BigBoss Way)
+1. Select **Operation**: `Merge Video & Audio`.
+2. Choose **Input Source**: `File Path`.
+3. Provide absolute paths for **Video File Path** and **Audio File Path**.
+   *Using File Paths avoids loading large binaries into n8n's memory, making the node faster and more stable.*
+
+### Advanced Transcoding
+1. Select **Operation**: `Convert / Transcode`.
+2. Set **Mode** to `BigBoss`.
+3. Select specific **Video Codec** (e.g., `H.264`) and **Audio Codec** (e.g., `AAC`).
+
+## 📥 Installation
+
+```bash
+npm install n8n-nodes-ffmpeg-bigboss
+```
+
+## 🏗️ Build from Source
+
+```bash
+npm install
+npm run build
+```
+
+## License
+
+MIT

package/dist/FFmpegBigBoss.node.js

@@ -0,0 +1,493 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FFmpegBigBoss = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const uuid_1 = require("uuid");
+const fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
+const ffmpeg_1 = __importDefault(require("@ffmpeg-installer/ffmpeg"));
+fluent_ffmpeg_1.default.setFfmpegPath(ffmpeg_1.default.path);
+class FFmpegBigBoss {
+    constructor() {
+        this.description = {
+            displayName: 'FFmpeg BigBoss',
+            name: 'ffmpegBigBoss',
+            icon: 'fa:film',
+            group: ['transform'],
+            version: 1,
+            description: 'Process video and audio using FFmpeg BigBoss capabilities',
+            defaults: {
+                name: 'FFmpeg BigBoss',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            properties: [
+                {
+                    displayName: 'Mode',
+                    name: 'mode',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Simple',
+                            value: 'simple',
+                        },
+                        {
+                            name: 'BigBoss',
+                            value: 'bigboss',
+                        },
+                    ],
+                    default: 'simple',
+                    description: 'Toggle between Simple (easy presets) and BigBoss (granular control) options',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Convert / Transcode',
+                            value: 'convert',
+                            description: 'Change format, resolution, or codec',
+                        },
+                        {
+                            name: 'Compress (Optimize)',
+                            value: 'compress',
+                            description: 'Reduce file size using CRF and presets',
+                        },
+                        {
+                            name: 'Extract Audio',
+                            value: 'extractAudio',
+                            description: 'Rip audio track from video',
+                        },
+                        {
+                            name: 'Merge Video & Audio',
+                            value: 'merge',
+                            description: 'Combine video and audio streams into a single file',
+                        },
+                        {
+                            name: 'Get Metadata',
+                            value: 'metadata',
+                            description: 'Analyze media streams',
+                        },
+                        {
+                            name: 'Custom Command',
+                            value: 'custom',
+                            description: 'Run raw FFmpeg arguments',
+                        },
+                    ],
+                    default: 'convert',
+                },
+                {
+                    displayName: 'Input Source',
+                    name: 'inputSource',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Binary Field',
+                            value: 'binary',
+                        },
+                        {
+                            name: 'File Path',
+                            value: 'path',
+                        },
+                    ],
+                    default: 'binary',
+                    displayOptions: {
+                        hide: {
+                            operation: ['merge'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Input File Path',
+                    name: 'inputPath',
+                    type: 'string',
+                    default: '',
+                    placeholder: '/path/to/video.mp4',
+                    displayOptions: {
+                        show: {
+                            inputSource: ['path'],
+                        },
+                        hide: {
+                            operation: ['merge'],
+                        }
+                    },
+                },
+                {
+                    displayName: 'Input Binary Field',
+                    name: 'binaryPropertyName',
+                    type: 'string',
+                    default: 'data',
+                    required: true,
+                    description: 'The name of the binary property containing the media file',
+                    displayOptions: {
+                        show: {
+                            inputSource: ['binary'],
+                        },
+                        hide: {
+                            operation: ['merge'],
+                        }
+                    },
+                },
+                {
+                    displayName: 'Input Source',
+                    name: 'mergeInputSource',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Binary Fields',
+                            value: 'binary',
+                        },
+                        {
+                            name: 'File Paths',
+                            value: 'path',
+                        },
+                    ],
+                    default: 'binary',
+                    displayOptions: {
+                        show: {
+                            operation: ['merge'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Video File Path',
+                    name: 'videoFilePath',
+                    type: 'string',
+                    default: '',
+                    placeholder: '/path/to/video.mp4',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['merge'],
+                            mergeInputSource: ['path'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Audio File Path',
+                    name: 'audioFilePath',
+                    type: 'string',
+                    default: '',
+                    placeholder: '/path/to/audio.mp3',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['merge'],
+                            mergeInputSource: ['path'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Video Binary Field',
+                    name: 'videoBinaryProperty',
+                    type: 'string',
+                    default: 'video',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['merge'],
+                            mergeInputSource: ['binary'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Audio Binary Field',
+                    name: 'audioBinaryProperty',
+                    type: 'string',
+                    default: 'audio',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['merge'],
+                            mergeInputSource: ['binary'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Output Format',
+                    name: 'format',
+                    type: 'options',
+                    options: [
+                        { name: 'MP4', value: 'mp4' },
+                        { name: 'WebM', value: 'webm' },
+                        { name: 'AVI', value: 'avi' },
+                        { name: 'MOV', value: 'mov' },
+                        { name: 'GIF', value: 'gif' },
+                    ],
+                    default: 'mp4',
+                    displayOptions: {
+                        show: {
+                            operation: ['convert', 'merge'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Video Codec',
+                    name: 'videoCodec',
+                    type: 'options',
+                    options: [
+                        { name: 'Auto', value: 'auto' },
+                        { name: 'Copy (Stream Copy)', value: 'copy' },
+                        { name: 'H.264 (libx264)', value: 'libx264' },
+                        { name: 'VP9 (libvpx-vp9)', value: 'libvpx-vp9' },
+                    ],
+                    default: 'auto',
+                    displayOptions: {
+                        show: {
+                            operation: ['convert', 'merge'],
+                            mode: ['bigboss'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Audio Codec',
+                    name: 'audioCodec',
+                    type: 'options',
+                    options: [
+                        { name: 'Auto', value: 'auto' },
+                        { name: 'AAC', value: 'aac' },
+                        { name: 'Opus (libopus)', value: 'libopus' },
+                    ],
+                    default: 'auto',
+                    displayOptions: {
+                        show: {
+                            operation: ['convert', 'merge'],
+                            mode: ['bigboss'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Preset',
+                    name: 'preset',
+                    type: 'options',
+                    options: [
+                        { name: 'Ultrafast', value: 'ultrafast' },
+                        { name: 'Superfast', value: 'superfast' },
+                        { name: 'Fast', value: 'fast' },
+                        { name: 'Medium', value: 'medium' },
+                        { name: 'Slow', value: 'slow' },
+                        { name: 'Veryslow', value: 'veryslow' },
+                    ],
+                    default: 'medium',
+                    displayOptions: {
+                        show: {
+                            operation: ['compress', 'convert'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'CRF (Quality)',
+                    name: 'crf',
+                    type: 'number',
+                    default: 23,
+                    typeOptions: { minValue: 0, maxValue: 51 },
+                    description: '0 is lossless, 23 is default, 51 is worst',
+                    displayOptions: {
+                        show: {
+                            operation: ['compress'],
+                            mode: ['bigboss'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Custom Arguments',
+                    name: 'customArgs',
+                    type: 'string',
+                    default: '-c:v libx264 -preset slow -crf 22',
+                    displayOptions: {
+                        show: {
+                            operation: ['custom'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Output Extension',
+                    name: 'outputExtension',
+                    type: 'string',
+                    default: 'mp4',
+                    displayOptions: {
+                        show: {
+                            operation: ['custom'],
+                        },
+                    },
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const tempDir = os.tmpdir();
+        const tempFilesToDelete = [];
+        try {
+            for (let i = 0; i < items.length; i++) {
+                const operation = this.getNodeParameter('operation', i);
+                let command;
+                let outputExtension = 'mp4';
+                if (operation === 'merge') {
+                    const mergeSource = this.getNodeParameter('mergeInputSource', i);
+                    let videoPath = '';
+                    let audioPath = '';
+                    if (mergeSource === 'path') {
+                        videoPath = this.getNodeParameter('videoFilePath', i);
+                        audioPath = this.getNodeParameter('audioFilePath', i);
+                        if (!fs.existsSync(videoPath))
+                            throw new Error(`Video not found: ${videoPath}`);
+                        if (!fs.existsSync(audioPath))
+                            throw new Error(`Audio not found: ${audioPath}`);
+                    }
+                    else {
+                        const vProp = this.getNodeParameter('videoBinaryProperty', i);
+                        const aProp = this.getNodeParameter('audioBinaryProperty', i);
+                        const vBuf = await this.helpers.getBinaryDataBuffer(i, vProp);
+                        const aBuf = await this.helpers.getBinaryDataBuffer(i, aProp);
+                        videoPath = path.join(tempDir, `vid_${(0, uuid_1.v4)()}`);
+                        audioPath = path.join(tempDir, `aud_${(0, uuid_1.v4)()}`);
+                        fs.writeFileSync(videoPath, vBuf);
+                        fs.writeFileSync(audioPath, aBuf);
+                        tempFilesToDelete.push(videoPath, audioPath);
+                    }
+                    command = (0, fluent_ffmpeg_1.default)();
+                    command.input(videoPath);
+                    command.input(audioPath);
+                    command.outputOptions([
+                        '-map 0:v',
+                        '-map 1:a',
+                        '-c:v copy',
+                        '-c:a aac',
+                    ]);
+                    outputExtension = this.getNodeParameter('format', i) || 'mp4';
+                }
+                else {
+                    const inputSource = this.getNodeParameter('inputSource', i);
+                    let inputPath = '';
+                    if (inputSource === 'path') {
+                        inputPath = this.getNodeParameter('inputPath', i);
+                        if (!fs.existsSync(inputPath))
+                            throw new Error(`Input not found: ${inputPath}`);
+                    }
+                    else {
+                        const prop = this.getNodeParameter('binaryPropertyName', i);
+                        const buf = await this.helpers.getBinaryDataBuffer(i, prop);
+                        inputPath = path.join(tempDir, `in_${(0, uuid_1.v4)()}`);
+                        fs.writeFileSync(inputPath, buf);
+                        tempFilesToDelete.push(inputPath);
+                    }
+                    command = (0, fluent_ffmpeg_1.default)(inputPath);
+                }
+                if (operation === 'convert') {
+                    outputExtension = this.getNodeParameter('format', i);
+                    const mode = this.getNodeParameter('mode', i);
+                    if (mode === 'bigboss') {
+                        const vCodec = this.getNodeParameter('videoCodec', i);
+                        const aCodec = this.getNodeParameter('audioCodec', i);
+                        if (vCodec !== 'auto')
+                            command.videoCodec(vCodec);
+                        if (aCodec !== 'auto')
+                            command.audioCodec(aCodec);
+                    }
+                    const preset = this.getNodeParameter('preset', i);
+                    command.outputOptions(`-preset ${preset}`);
+                }
+                else if (operation === 'compress') {
+                    const crf = this.getNodeParameter('crf', i);
+                    const preset = this.getNodeParameter('preset', i);
+                    command.videoCodec('libx264').outputOptions(`-crf ${crf}`).outputOptions(`-preset ${preset}`);
+                }
+                else if (operation === 'custom') {
+                    const args = this.getNodeParameter('customArgs', i);
+                    outputExtension = this.getNodeParameter('outputExtension', i);
+                    command.outputOptions(args.split(' ').filter(a => a));
+                }
+                if (operation === 'metadata') {
+                    const metadata = await new Promise((resolve, reject) => {
+                        command.ffprobe((err, data) => {
+                            if (err)
+                                reject(err);
+                            else
+                                resolve(data);
+                        });
+                    });
+                    returnData.push({
+                        json: metadata,
+                        binary: items[i].binary,
+                    });
+                    continue;
+                }
+                const outName = `out_${(0, uuid_1.v4)()}.${outputExtension}`;
+                const outPath = path.join(tempDir, outName);
+                await new Promise((resolve, reject) => {
+                    command
+                        .on('end', () => resolve(true))
+                        .on('error', (err) => reject(new Error(`FFmpeg failed: ${err.message}`)))
+                        .save(outPath);
+                });
+                const outBuf = fs.readFileSync(outPath);
+                const binaryData = await this.helpers.prepareBinaryData(outBuf, outName);
+                returnData.push({
+                    json: items[i].json,
+                    binary: {
+                        data: binaryData
+                    }
+                });
+                if (fs.existsSync(outPath))
+                    fs.unlinkSync(outPath);
+            }
+        }
+        catch (error) {
+            if (this.continueOnFail()) {
+                returnData.push({ json: { error: error.message }, binary: {} });
+            }
+            else {
+                throw error;
+            }
+        }
+        finally {
+            tempFilesToDelete.forEach(f => {
+                if (fs.existsSync(f))
+                    fs.unlinkSync(f);
+            });
+        }
+        return [returnData];
+    }
+}
+exports.FFmpegBigBoss = FFmpegBigBoss;

package/package.json

@@ -0,0 +1,50 @@
+{
+    "name": "n8n-nodes-ffmpeg-bigboss",
+    "version": "1.0.0",
+    "description": "BigBoss audiovisual processing node for n8n based on FFmpeg research",
+    "keywords": [
+        "n8n-community-node-package",
+        "n8n",
+        "ffmpeg",
+        "video",
+        "audio",
+        "transcode"
+    ],
+    "license": "MIT",
+    "author": "isemo007",
+    "main": "index.js",
+    "scripts": {
+        "build": "tsc && gulp build:icons",
+        "dev": "tsc --watch",
+        "format": "prettier nodes --write",
+        "lint": "eslint nodes package.json",
+        "lintfix": "eslint nodes package.json --fix"
+    },
+    "files": [
+        "dist"
+    ],
+    "n8n": {
+        "n8nNodesApiVersion": 1,
+        "nodes": [
+            "dist/FFmpegBigBoss.node.js"
+        ]
+    },
+    "devDependencies": {
+        "@types/node": "^22.13.0",
+        "@typescript-eslint/parser": "~5.45",
+        "eslint-plugin-n8n-nodes-base": "^1.11.0",
+        "gulp": "^4.0.2",
+        "n8n-workflow": "^1.70.0",
+        "prettier": "^2.7.1",
+        "typescript": "^5.0.0"
+    },
+    "peerDependencies": {
+        "n8n-workflow": "*"
+    },
+    "dependencies": {
+        "n8n-core": "^1.75.0",
+        "fluent-ffmpeg": "^2.1.2",
+        "@ffmpeg-installer/ffmpeg": "^1.1.0",
+        "uuid": "^9.0.0"
+    }
+}