whispermix 1.2.2 → 1.3.4

package/README.md

@@ -53,6 +53,12 @@ whisperGroq.fromStream(audioStream)
   .catch(error => console.error(error));
 ```
 
+### ⏱️ Long Audio Processing
+
+WhisperMix automatically handles long audio files by splitting them into smaller segments if they exceed 15 minutes in duration. This process is transparent to the user:
+
+The segmented transcriptions are automatically merged into a single result, ensuring a smooth experience when working with content of any length.
+
 ### 🚦 Bottleneck Configuration
 
 WhisperMix uses Bottleneck for rate limiting. You can configure the Bottleneck settings when initializing WhisperMix:
@@ -88,7 +94,7 @@ Creates a new WhisperMix instance.
 
 - `options.model`: The model to use for transcription. Can be 'whisper-1' (OpenAI) or 'whisper-large-v3' (Groq).
 - `options.bottleneck`: (Optional) Configuration for Bottleneck rate limiting.
-
+- `options.chunkSize`: (Optional) The size in seconds of the chunks to split the audio into. Default is 890 seconds.
 ### `whisper.fromFile(filePath)`
 
 Transcribes audio from a file.

package/index.js

@@ -2,6 +2,10 @@ const axios = require('axios');
 const FormData = require('form-data');
 const fs = require('fs');
 const Bottleneck = require('bottleneck');
+const path = require('path');
+const ffmpeg = require('fluent-ffmpeg');
+const { getAudioDurationInSeconds } = require('get-audio-duration');
+const os = require('os'); // For temporary directory
 
 class WhisperMix {
     constructor(setup = {}) {
@@ -13,6 +17,7 @@ class WhisperMix {
             reservoirRefreshAmount: 18,
             reservoirRefreshInterval: 60000
         };
+        this.chunkSize = 15 * 60 - 10; // 14 minutes 50 seconds
 
         const config = {
             'whisper-1': {
@@ -34,7 +39,61 @@ class WhisperMix {
     }
 
     async fromFile(filePath) {
-        return this.fromStream(fs.createReadStream(filePath));
+        const absolutePath = path.resolve(filePath);
+        const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'whispermix-chunks-'));
+
+        try {
+            const duration = await getAudioDurationInSeconds(absolutePath);
+
+            if (duration <= this.chunkSize) {
+                // Process as a single file
+                return this.fromStream(fs.createReadStream(absolutePath));
+            } else {
+                // Split audio and process chunks
+                let accumulatedTranscription = "";
+                const numChunks = Math.ceil(duration / this.chunkSize);
+
+                for (let i = 0; i < numChunks; i++) {
+                    const chunkPath = path.join(tempDir, `chunk-${i}.mp3`);
+                    const startTime = i * this.chunkSize;
+                    
+                    await new Promise((resolve, reject) => {
+                        ffmpeg(absolutePath)
+                            .setStartTime(startTime)
+                            .setDuration(this.chunkSize)
+                            .output(chunkPath)
+                            .on('end', () => {
+                                console.log(`Chunk ${i + 1}/${numChunks} created: ${chunkPath}`);
+                                resolve();
+                            })
+                            .on('error', (err) => {
+                                console.error(`Error creating chunk ${i + 1}:`, err);
+                                reject(err);
+                            })
+                            .run();
+                    });
+
+                    const chunkStream = fs.createReadStream(chunkPath);
+                    const transcription = await this.fromStream(chunkStream);
+                    accumulatedTranscription += (transcription + " ").trimStart();
+                    
+                    // Clean up chunk immediately after processing
+                    try {
+                        await fs.promises.unlink(chunkPath);
+                    } catch (unlinkErr) {
+                        console.warn(`Could not delete chunk ${chunkPath}:`, unlinkErr);
+                    }
+                }
+                return accumulatedTranscription.trim();
+            }
+        } finally {
+            // Clean up the temporary directory
+            try {
+                await fs.promises.rm(tempDir, { recursive: true, force: true });
+            } catch (rmErr) {
+                console.warn(`Could not delete temporary directory ${tempDir}:`, rmErr);
+            }
+        }
     }
 
     async fromStream(audioStream) {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "whispermix",
     "description": "🎙️ WhisperMix is a versatile module for transcribing audio using OpenAI’s Whisper or Groq’s Whisper v3 model.",
-    "version": "1.2.2",
+    "version": "1.3.4",
     "keywords": [
         "whisper",
         "openai",
@@ -23,7 +23,8 @@
         "streaming",
         "file-processing",
         "multilingual",
-        "bottleneck"
+        "bottleneck",
+        "clasen"
     ],
     "repository": {
         "type": "git",
@@ -39,8 +40,10 @@
         "url": "https://github.com/clasen/WhisperMix/issues"
     },
     "dependencies": {
-        "axios": "^1.7.4",
+        "axios": "^1.9.0",
         "bottleneck": "^2.19.5",
-        "form-data": "^4.0.0"
+        "fluent-ffmpeg": "^2.1.3",
+        "form-data": "^4.0.0",
+        "get-audio-duration": "^4.0.1"
     }
 }