sfxmix 1.2.2 → 1.2.6

package/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(node:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

package/demo/demo_7.mjs

@@ -0,0 +1,15 @@
+import SfxMix from '../index.js';
+const sfx = new SfxMix();
+
+
+// Trim silence from beginning and end of to_trim.mp3
+await sfx
+    .add('to_trim.mp3')
+    .trim()
+    .save('trimmed_audio.ogg')
+    .then(() => {
+        console.log('Successfully exported: trimmed_audio.ogg');
+    })
+    .catch((error) => {
+        console.error('Error during audio processing:', error);
+    });

package/index.js

@@ -2,6 +2,7 @@ const ffmpeg = require('fluent-ffmpeg');
 const fs = require('fs');
 const path = require('path');
 const { v4: uuidv4 } = require('uuid');
+const { Readable } = require('stream');
 
 class SfxMix {
     constructor(config = {}) {
@@ -47,7 +48,103 @@ class SfxMix {
         return this;
     }
 
+    exportOgg(output) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                for (let action of this.actions) {
+                    if (action.type === 'add') {
+                        if (this.currentFile == null) {
+                            this.currentFile = path.isAbsolute(action.input) ? action.input : path.resolve(process.cwd(), action.input);
+                        } else {
+                            const tempFile = path.join(this.TMP_DIR, `temp_concat_${uuidv4()}.mp3`);
+                            await this.concatenateAudioFiles([this.currentFile, action.input], tempFile);
+                            if (this.isTempFile(this.currentFile)) {
+                                fs.unlinkSync(this.currentFile);
+                            }
+                            this.currentFile = tempFile;
+                        }
+                    } else if (action.type === 'mix') {
+                        if (this.currentFile == null) {
+                            throw new Error('No audio to mix with. Add or concatenate audio before mixing.');
+                        }
+                        const tempFile = path.join(this.TMP_DIR, `temp_mix_${uuidv4()}.mp3`);
+                        await this.mixAudioFiles(this.currentFile, action.input, tempFile, action.options);
+                        if (this.isTempFile(this.currentFile)) {
+                            fs.unlinkSync(this.currentFile);
+                        }
+                        this.currentFile = tempFile;
+                    } else if (action.type === 'silence') {
+                        const tempSilenceFile = path.join(this.TMP_DIR, `temp_silence_${uuidv4()}.mp3`);
+                        await this.generateSilence(action.duration, tempSilenceFile);
+                        if (this.currentFile == null) {
+                            this.currentFile = tempSilenceFile;
+                        } else {
+                            const tempFile = path.join(this.TMP_DIR, `temp_concat_${uuidv4()}.mp3`);
+                            await this.concatenateAudioFiles([this.currentFile, tempSilenceFile], tempFile);
+                            if (this.isTempFile(this.currentFile)) {
+                                fs.unlinkSync(this.currentFile);
+                            }
+                            fs.unlinkSync(tempSilenceFile);
+                            this.currentFile = tempFile;
+                        }
+                    } else if (action.type === 'filter') {
+                        if (this.currentFile == null) {
+                            throw new Error('No audio to apply filter to. Add audio before applying filters.');
+                        }
+                        const tempFile = path.join(this.TMP_DIR, `temp_filter_${uuidv4()}.mp3`);
+                        await this.applyFilter(this.currentFile, action.filterName, action.options, tempFile);
+                        if (this.isTempFile(this.currentFile)) {
+                            fs.unlinkSync(this.currentFile);
+                        }
+                        this.currentFile = tempFile;
+                    }
+                }
+                
+                const absoluteOutput = path.resolve(process.cwd(), output);
+                const outputDir = path.dirname(absoluteOutput);
+
+                if (!fs.existsSync(outputDir)) {
+                    fs.mkdirSync(outputDir, { recursive: true });
+                }
+
+                if (!fs.existsSync(this.currentFile)) {
+                    throw new Error(`Source file does not exist: ${this.currentFile}`);
+                }
+
+                await this.convertToOgg(this.currentFile, absoluteOutput);
+
+                if (this.isTempFile(this.currentFile)) {
+                    fs.unlinkSync(this.currentFile);
+                }
+
+                this.reset();
+                resolve(absoluteOutput);
+            } catch (err) {
+                console.error('Error during OGG export:', err);
+                reject(err);
+            }
+        });
+    }
+
+    convertToOgg(inputFile, outputFile) {
+        return new Promise((resolve, reject) => {
+            ffmpeg()
+                .input(inputFile)
+                .audioCodec('libopus')
+                .format('ogg')
+                .output(outputFile)
+                .on('end', () => resolve())
+                .on('error', (err) => reject(err))
+                .run();
+        });
+    }
+
     save(output) {
+        // Check if output file has .ogg extension
+        if (output.toLowerCase().endsWith('.ogg')) {
+            return this.exportOgg(output);
+        }
+        
         return new Promise(async (resolve, reject) => {
             try {
                 for (let action of this.actions) {
@@ -201,8 +298,8 @@ class SfxMix {
                         },
                     },
                 ])
-                .audioCodec('libmp3lame') // Ensure the codec is MP3
-                .format('mp3') // Ensure the format is MP3
+                .audioCodec('libmp3lame')
+                .format('mp3')
                 .output(outputFile)
                 .on('end', () => resolve())
                 .on('error', (err) => reject(err))
@@ -213,9 +310,29 @@ class SfxMix {
     generateSilence(durationMs, outputFile) {
         return new Promise((resolve, reject) => {
             const durationSec = durationMs / 1000;
+            const sampleRate = 44100;
+            const numChannels = 2; // Stereo
+            const bytesPerSample = 2; // 16-bit audio
+            const bytesPerSecond = sampleRate * numChannels * bytesPerSample;
+            let totalBytes = Math.floor(durationSec * bytesPerSecond);
+
+            const silenceStream = new Readable({
+                read(size) {
+                    const chunkSize = Math.min(size, totalBytes);
+                    if (chunkSize <= 0) {
+                        this.push(null);
+                        return;
+                    }
+                    this.push(Buffer.alloc(chunkSize, 0));
+                    totalBytes -= chunkSize;
+                }
+            });
+
             ffmpeg()
-                .input('anullsrc=channel_layout=stereo:sample_rate=44100')
-                .inputOptions(['-f', 'lavfi', '-t', `${durationSec}`])
+                .input(silenceStream)
+                .inputFormat('s16le')
+                .audioChannels(numChannels)
+                .audioFrequency(sampleRate)
                 .audioCodec('libmp3lame')
                 .format('mp3')
                 .output(outputFile)

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "sfxmix",
     "description": "🎧 SfxMix - Powerful and easy-to-use module for processing audio.",
-    "version": "1.2.2",
+    "version": "1.2.6",
     "main": "index.js",
     "dependencies": {
         "fluent-ffmpeg": "^2.1.3",
@@ -20,6 +20,8 @@
         "filters",
         "mp3",
         "wav",
+        "ogg",
+        "opus",
         "echo",
         "delay",
         "tremolo",