n8n-nodes-tts-bigboss 1.0.8 → 2.0.0

package/dist/TTSBigBoss.node.js

@@ -48,6 +48,134 @@ const http = __importStar(require("http"));
 const stream = __importStar(require("stream"));
 const util_1 = require("util");
 const pipeline = (0, util_1.promisify)(stream.pipeline);
+const MAX_CHARS_PER_CHUNK = 300;
+const SILENCE_DURATION_MS = 200;
+function splitTextIntoChunks(text) {
+    const chunks = [];
+    const sentences = text.match(/[^.!?]+[.!?]*/g) || [text];
+    let currentChunk = '';
+    for (const sentence of sentences) {
+        if (currentChunk.length + sentence.length <= MAX_CHARS_PER_CHUNK) {
+            currentChunk += sentence;
+        }
+        else {
+            if (currentChunk.length > 0) {
+                chunks.push(currentChunk.trim());
+            }
+            currentChunk = sentence;
+            while (currentChunk.length > MAX_CHARS_PER_CHUNK) {
+                let splitPoint = currentChunk.lastIndexOf(' ', MAX_CHARS_PER_CHUNK);
+                if (splitPoint === -1) {
+                    splitPoint = MAX_CHARS_PER_CHUNK;
+                }
+                chunks.push(currentChunk.substring(0, splitPoint).trim());
+                currentChunk = currentChunk.substring(splitPoint).trim();
+            }
+        }
+    }
+    if (currentChunk.length > 0) {
+        chunks.push(currentChunk.trim());
+    }
+    return chunks.filter(chunk => chunk.length > 0);
+}
+function createWavBuffer(audioData, sampleRate = 24000) {
+    const numChannels = 1;
+    const bitsPerSample = 16;
+    const bytesPerSample = bitsPerSample / 8;
+    let int16Data;
+    if (audioData instanceof Float32Array) {
+        int16Data = new Int16Array(audioData.length);
+        for (let i = 0; i < audioData.length; i++) {
+            const s = Math.max(-1, Math.min(1, audioData[i]));
+            int16Data[i] = s < 0 ? s * 0x8000 : s * 0x7FFF;
+        }
+    }
+    else {
+        int16Data = new Int16Array(audioData.buffer, audioData.byteOffset, audioData.byteLength / 2);
+    }
+    const dataSize = int16Data.length * bytesPerSample;
+    const buffer = Buffer.alloc(44 + dataSize);
+    buffer.write('RIFF', 0);
+    buffer.writeUInt32LE(36 + dataSize, 4);
+    buffer.write('WAVE', 8);
+    buffer.write('fmt ', 12);
+    buffer.writeUInt32LE(16, 16);
+    buffer.writeUInt16LE(1, 20);
+    buffer.writeUInt16LE(numChannels, 22);
+    buffer.writeUInt32LE(sampleRate, 24);
+    buffer.writeUInt32LE(sampleRate * numChannels * bytesPerSample, 28);
+    buffer.writeUInt16LE(numChannels * bytesPerSample, 32);
+    buffer.writeUInt16LE(bitsPerSample, 34);
+    buffer.write('data', 36);
+    buffer.writeUInt32LE(dataSize, 40);
+    for (let i = 0; i < int16Data.length; i++) {
+        buffer.writeInt16LE(int16Data[i], 44 + i * 2);
+    }
+    return buffer;
+}
+function concatenateAudioBuffers(audioChunks, silenceDurationMs, sampleRate = 24000) {
+    if (audioChunks.length === 0) {
+        return createWavBuffer(new Float32Array(), sampleRate);
+    }
+    if (audioChunks.length === 1) {
+        return audioChunks[0].audio instanceof Buffer
+            ? audioChunks[0].audio
+            : createWavBuffer(audioChunks[0].audio, audioChunks[0].sampling_rate);
+    }
+    const silenceSamples = Math.round((silenceDurationMs / 1000) * sampleRate);
+    let totalLength = 0;
+    const float32Chunks = [];
+    for (const chunk of audioChunks) {
+        if (chunk.audio instanceof Float32Array) {
+            float32Chunks.push(chunk.audio);
+            totalLength += chunk.audio.length;
+        }
+        else {
+            const int16 = new Int16Array(chunk.audio.buffer, chunk.audio.byteOffset, chunk.audio.byteLength / 2);
+            const float32 = new Float32Array(int16.length);
+            for (let i = 0; i < int16.length; i++) {
+                float32[i] = int16[i] / (int16[i] < 0 ? 0x8000 : 0x7FFF);
+            }
+            float32Chunks.push(float32);
+            totalLength += float32.length;
+        }
+    }
+    totalLength += (audioChunks.length - 1) * silenceSamples;
+    const combinedAudio = new Float32Array(totalLength);
+    let offset = 0;
+    for (let i = 0; i < float32Chunks.length; i++) {
+        const chunk = float32Chunks[i];
+        combinedAudio.set(chunk, offset);
+        offset += chunk.length;
+        if (i < float32Chunks.length - 1) {
+            offset += silenceSamples;
+        }
+    }
+    return createWavBuffer(combinedAudio, sampleRate);
+}
+function generateSRTFromChunks(textChunks, audioDurations) {
+    if (textChunks.length === 0)
+        return '';
+    let srt = '';
+    let currentTime = 0;
+    let counter = 1;
+    const msToSrt = (ms) => {
+        const totalSec = Math.floor(ms / 1000);
+        const mili = Math.floor(ms % 1000);
+        const h = Math.floor(totalSec / 3600);
+        const m = Math.floor((totalSec % 3600) / 60);
+        const s = totalSec % 60;
+        return `${h.toString().padStart(2, '0')}:${m.toString().padStart(2, '0')}:${s.toString().padStart(2, '0')},${mili.toString().padStart(3, '0')}`;
+    };
+    for (let i = 0; i < textChunks.length; i++) {
+        const duration = audioDurations[i] || 0;
+        const startTime = currentTime;
+        const endTime = currentTime + duration;
+        srt += `${counter++}\n${msToSrt(startTime)} --> ${msToSrt(endTime)}\n${textChunks[i].trim()}\n\n`;
+        currentTime = endTime + SILENCE_DURATION_MS;
+    }
+    return srt;
+}
 const PIPER_MODELS = [
     { name: 'Arabic (Jordan) - Kareem (Male) - Low', value: 'ar_JO-kareem-low' },
     { name: 'Arabic (Jordan) - Kareem (Male) - Medium', value: 'ar_JO-kareem-medium' },

package/nodes/TTSBigBoss/TTSBigBoss.node.ts

@@ -5,6 +5,7 @@ import {
     INodeTypeDescription,
     ILoadOptionsFunctions,
     INodePropertyOptions,
+    NodeOperationError,
 } from 'n8n-workflow';
 import { v4 as uuidv4 } from 'uuid';
 import * as fs from 'fs';
@@ -20,6 +21,194 @@ import * as zlib from 'zlib'; // For extracting .tar.gz if needed, typically usa
 
 const pipeline = promisify(stream.pipeline);
 
+// =============================================================================
+// CORE HELPER FUNCTIONS
+// =============================================================================
+
+const MAX_CHARS_PER_CHUNK = 300; // Estimated safe limit for ~20-25 seconds of audio
+const SILENCE_DURATION_MS = 200; // 200ms pause between concatenated audio chunks
+
+interface AudioChunk {
+    audio: Float32Array | Buffer;
+    sampling_rate: number;
+}
+
+/**
+ * Splits text into chunks based on sentence endings and a maximum character limit.
+ * Tries to keep sentences together and avoids splitting words.
+ */
+function splitTextIntoChunks(text: string): string[] {
+    const chunks: string[] = [];
+    const sentences = text.match(/[^.!?]+[.!?]*/g) || [text];
+    let currentChunk = '';
+
+    for (const sentence of sentences) {
+        if (currentChunk.length + sentence.length <= MAX_CHARS_PER_CHUNK) {
+            currentChunk += sentence;
+        } else {
+            if (currentChunk.length > 0) {
+                chunks.push(currentChunk.trim());
+            }
+            currentChunk = sentence;
+
+            // If a single sentence is still too long, split it further
+            while (currentChunk.length > MAX_CHARS_PER_CHUNK) {
+                let splitPoint = currentChunk.lastIndexOf(' ', MAX_CHARS_PER_CHUNK);
+                if (splitPoint === -1) {
+                    splitPoint = MAX_CHARS_PER_CHUNK;
+                }
+                chunks.push(currentChunk.substring(0, splitPoint).trim());
+                currentChunk = currentChunk.substring(splitPoint).trim();
+            }
+        }
+    }
+
+    if (currentChunk.length > 0) {
+        chunks.push(currentChunk.trim());
+    }
+
+    return chunks.filter(chunk => chunk.length > 0);
+}
+
+/**
+ * Create a WAV file buffer from raw PCM audio data
+ */
+function createWavBuffer(audioData: Float32Array | Buffer, sampleRate: number = 24000): Buffer {
+    const numChannels = 1; // Mono
+    const bitsPerSample = 16;
+    const bytesPerSample = bitsPerSample / 8;
+
+    // Convert Float32Array to Int16Array if needed
+    let int16Data: Int16Array;
+    if (audioData instanceof Float32Array) {
+        int16Data = new Int16Array(audioData.length);
+        for (let i = 0; i < audioData.length; i++) {
+            const s = Math.max(-1, Math.min(1, audioData[i]));
+            int16Data[i] = s < 0 ? s * 0x8000 : s * 0x7FFF;
+        }
+    } else {
+        // Already a buffer, assume it's raw PCM int16
+        int16Data = new Int16Array(audioData.buffer, audioData.byteOffset, audioData.byteLength / 2);
+    }
+
+    const dataSize = int16Data.length * bytesPerSample;
+    const buffer = Buffer.alloc(44 + dataSize);
+
+    // WAV header
+    buffer.write('RIFF', 0);
+    buffer.writeUInt32LE(36 + dataSize, 4);
+    buffer.write('WAVE', 8);
+    buffer.write('fmt ', 12);
+    buffer.writeUInt32LE(16, 16); // PCM format chunk size
+    buffer.writeUInt16LE(1, 20); // PCM format
+    buffer.writeUInt16LE(numChannels, 22);
+    buffer.writeUInt32LE(sampleRate, 24);
+    buffer.writeUInt32LE(sampleRate * numChannels * bytesPerSample, 28); // Byte rate
+    buffer.writeUInt16LE(numChannels * bytesPerSample, 32); // Block align
+    buffer.writeUInt16LE(bitsPerSample, 34);
+    buffer.write('data', 36);
+    buffer.writeUInt32LE(dataSize, 40);
+
+    // Write PCM data
+    for (let i = 0; i < int16Data.length; i++) {
+        buffer.writeInt16LE(int16Data[i], 44 + i * 2);
+    }
+
+    return buffer;
+}
+
+/**
+ * Concatenates multiple audio buffers and adds silence between them.
+ * Handles both Buffer and Float32Array inputs.
+ */
+function concatenateAudioBuffers(
+    audioChunks: AudioChunk[],
+    silenceDurationMs: number,
+    sampleRate: number = 24000
+): Buffer {
+    if (audioChunks.length === 0) {
+        return createWavBuffer(new Float32Array(), sampleRate);
+    }
+
+    if (audioChunks.length === 1) {
+        return audioChunks[0].audio instanceof Buffer
+            ? audioChunks[0].audio
+            : createWavBuffer(audioChunks[0].audio, audioChunks[0].sampling_rate);
+    }
+
+    // Calculate total length including silence
+    const silenceSamples = Math.round((silenceDurationMs / 1000) * sampleRate);
+    let totalLength = 0;
+
+    // Convert all to Float32Array for easier concatenation
+    const float32Chunks: Float32Array[] = [];
+    for (const chunk of audioChunks) {
+        if (chunk.audio instanceof Float32Array) {
+            float32Chunks.push(chunk.audio);
+            totalLength += chunk.audio.length;
+        } else {
+            // Convert Buffer to Float32Array (assuming 16-bit PCM)
+            const int16 = new Int16Array(chunk.audio.buffer, chunk.audio.byteOffset, chunk.audio.byteLength / 2);
+            const float32 = new Float32Array(int16.length);
+            for (let i = 0; i < int16.length; i++) {
+                float32[i] = int16[i] / (int16[i] < 0 ? 0x8000 : 0x7FFF);
+            }
+            float32Chunks.push(float32);
+            totalLength += float32.length;
+        }
+    }
+
+    totalLength += (audioChunks.length - 1) * silenceSamples;
+
+    const combinedAudio = new Float32Array(totalLength);
+    let offset = 0;
+
+    for (let i = 0; i < float32Chunks.length; i++) {
+        const chunk = float32Chunks[i];
+        combinedAudio.set(chunk, offset);
+        offset += chunk.length;
+
+        // Add silence if not the last chunk
+        if (i < float32Chunks.length - 1) {
+            offset += silenceSamples;
+        }
+    }
+
+    return createWavBuffer(combinedAudio, sampleRate);
+}
+
+/**
+ * Generate SRT subtitles for concatenated audio chunks
+ */
+function generateSRTFromChunks(textChunks: string[], audioDurations: number[]): string {
+    if (textChunks.length === 0) return '';
+
+    let srt = '';
+    let currentTime = 0;
+    let counter = 1;
+
+    const msToSrt = (ms: number) => {
+        const totalSec = Math.floor(ms / 1000);
+        const mili = Math.floor(ms % 1000);
+        const h = Math.floor(totalSec / 3600);
+        const m = Math.floor((totalSec % 3600) / 60);
+        const s = totalSec % 60;
+        return `${h.toString().padStart(2, '0')}:${m.toString().padStart(2, '0')}:${s.toString().padStart(2, '0')},${mili.toString().padStart(3, '0')}`;
+    };
+
+    for (let i = 0; i < textChunks.length; i++) {
+        const duration = audioDurations[i] || 0;
+        const startTime = currentTime;
+        const endTime = currentTime + duration;
+
+        srt += `${counter++}\n${msToSrt(startTime)} --> ${msToSrt(endTime)}\n${textChunks[i].trim()}\n\n`;
+        currentTime = endTime + SILENCE_DURATION_MS; // Add silence duration
+    }
+
+    return srt;
+}
+
+
 // Piper Models List (Curated High Quality)
 // Note: Official Piper repo currently only has 'kareem' (Male) for Arabic.
 // For Female Arabic voices, please use the 'Edge TTS' engine (Salma, Zariyah).

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "n8n-nodes-tts-bigboss",
-  "version": "1.0.8",
-  "description": "BigBoss TTS node with multi-engine support and automatic SRT generation",
+  "version": "2.0.0",
+  "description": "Professional TTS node with multi-engine support, text chunking, and accurate SRT generation",
   "keywords": [
     "n8n-community-node-package",
     "n8n",
@@ -10,7 +10,8 @@
     "srt",
     "arabic",
     "edge-tts",
-    "piper"
+    "piper",
+    "kokoro"
   ],
   "license": "MIT",
   "author": "isemo007",
@@ -35,7 +36,8 @@
     "n8n-core": "^1.75.0",
     "n8n-workflow": "^1.70.0",
     "uuid": "^9.0.0",
-    "ws": "^8.13.0"
+    "ws": "^8.13.0",
+    "kokoro-js": "^1.2.1"
   },
   "devDependencies": {
     "@types/lodash": "^4.14.195",
@@ -50,5 +52,8 @@
     "typescript": "^5.0.0",
     "webpack": "^5.88.0",
     "webpack-cli": "^5.1.4"
+  },
+  "engines": {
+    "node": ">=18.0.0"
   }
 }