sfxmix 1.2.8 → 1.3.2

package/README.md

@@ -240,7 +240,7 @@ sfx.save('output.mp3');
 Normalizes audio loudness to a specified target using the EBU R128 standard.
 
 - **Options:**
-  - `tp` (number): Maximum true peak level in dBTP (default: `-3`).
+  - `tp` (number): Maximum true peak level in dBTP (default: `-1.5`).
   - `i` (number): Target integrated loudness in LUFS (default: `-20`).
   - `lra` (number): Loudness range in LU (default: `11`).
 

package/demo/demo_8.js

@@ -0,0 +1,33 @@
+import SfxMix from '../index.js';
+
+// Example 1: Trim silence without padding
+console.log('Example 1: Trimming without padding...');
+const sfx1 = new SfxMix();
+await sfx1
+    .add('part1.mp3')
+    .trim()
+    .save('part1_trimmed.mp3')
+    .then(() => {
+        console.log('✓ Successfully exported: vo_intro_text_3_trimmed.mp3');
+    })
+    .catch((error) => {
+        console.error('Error during audio processing:', error);
+    });
+
+// Example 2: Trim silence with padding (200ms at start, 300ms at end)
+console.log('\nExample 2: Trimming with padding...');
+const sfx2 = new SfxMix();
+await sfx2
+    .add('part1.mp3')
+    .trim({ 
+        paddingStart: 100,  // 100ms of silence at the start
+        paddingEnd: 100     // 100ms of silence at the end
+    })
+    .save('part1_trimmed_padded.mp3')
+    .then(() => {
+        console.log('✓ Successfully exported: vo_intro_text_3_trimmed_padded.mp3');
+    })
+    .catch((error) => {
+        console.error('Error during audio processing:', error);
+    });
+

package/demo/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "demo",
+  "version": "1.0.0",
+  "description": "",
+  "license": "ISC",
+  "author": "",
+  "type": "module",
+  "main": "demo_1.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}

package/index.js

@@ -9,6 +9,9 @@ class SfxMix {
         this.actions = [];
         this.currentFile = null;
         this.TMP_DIR = path.resolve(config.tmpDir || path.join(__dirname, 'tmp'));
+        
+        // Default bitrate: null = auto-detect, or specify a value (e.g., 64000, 128000, 192000)
+        this.bitrate = config.bitrate !== undefined ? config.bitrate : 64000;
 
         // Ensure the temporary directory exists and is writable
         try {
@@ -48,6 +51,11 @@ class SfxMix {
         return this;
     }
 
+    trim(options = {}) {
+        this.actions.push({ type: 'trim', options });
+        return this;
+    }
+
 
 
     convertAudio(inputFile, outputFile, outputOptions = {}) {
@@ -127,7 +135,16 @@ class SfxMix {
                         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);
+                        // Get audio info from current file to match channels and sample rate
+                        let audioInfo = null;
+                        if (this.currentFile != null) {
+                            try {
+                                audioInfo = await this.getAudioInfo(this.currentFile);
+                            } catch (err) {
+                                console.warn('Could not get audio info, using defaults:', err.message);
+                            }
+                        }
+                        await this.generateSilence(action.duration, tempSilenceFile, audioInfo);
                         if (this.currentFile == null) {
                             this.currentFile = tempSilenceFile;
                         } else {
@@ -149,6 +166,16 @@ class SfxMix {
                             fs.unlinkSync(this.currentFile);
                         }
                         this.currentFile = tempFile;
+                    } else if (action.type === 'trim') {
+                        if (this.currentFile == null) {
+                            throw new Error('No audio to trim. Add audio before trimming.');
+                        }
+                        const tempFile = path.join(this.TMP_DIR, `temp_trim_${uuidv4()}.mp3`);
+                        await this.applyTrim(this.currentFile, action.options, tempFile);
+                        if (this.isTempFile(this.currentFile)) {
+                            fs.unlinkSync(this.currentFile);
+                        }
+                        this.currentFile = tempFile;
                     }
                 }
                 
@@ -212,7 +239,8 @@ class SfxMix {
             filename.includes('temp_concat_') ||
             filename.includes('temp_mix_') ||
             filename.includes('temp_silence_') ||
-            filename.includes('temp_filter_')
+            filename.includes('temp_filter_') ||
+            filename.includes('temp_trim_')
         );
     }
 
@@ -274,11 +302,38 @@ class SfxMix {
         });
     }
 
-    generateSilence(durationMs, outputFile) {
+    getAudioInfo(inputFile) {
+        return new Promise((resolve, reject) => {
+            ffmpeg.ffprobe(inputFile, (err, metadata) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                
+                const audioStream = metadata.streams.find(s => s.codec_type === 'audio');
+                if (!audioStream) {
+                    reject(new Error('No audio stream found'));
+                    return;
+                }
+                
+                resolve({
+                    channels: audioStream.channels || 2,
+                    sampleRate: audioStream.sample_rate || 44100,
+                    bitrate: metadata.format.bit_rate || 128000
+                });
+            });
+        });
+    }
+
+    generateSilence(durationMs, outputFile, audioInfo = null) {
         return new Promise((resolve, reject) => {
             const durationSec = durationMs / 1000;
-            const sampleRate = 44100;
-            const numChannels = 2; // Stereo
+            const sampleRate = audioInfo?.sampleRate || 44100;
+            const numChannels = audioInfo?.channels || 2;
+            
+            // Use audioInfo bitrate if available, otherwise use bitrate or 128000 as fallback
+            const bitrate = audioInfo?.bitrate || this.bitrate || 128000;
+            
             const bytesPerSample = 2; // 16-bit audio
             const bytesPerSecond = sampleRate * numChannels * bytesPerSample;
             let totalBytes = Math.floor(durationSec * bytesPerSecond);
@@ -295,12 +350,15 @@ class SfxMix {
                 }
             });
 
+            const bitrateKbps = Math.floor(bitrate / 1000) + 'k';
+
             ffmpeg()
                 .input(silenceStream)
                 .inputFormat('s16le')
                 .audioChannels(numChannels)
                 .audioFrequency(sampleRate)
                 .audioCodec('libmp3lame')
+                .audioBitrate(bitrateKbps)
                 .format('mp3')
                 .output(outputFile)
                 .on('end', () => {
@@ -316,32 +374,132 @@ class SfxMix {
     }
 
     applyFilter(inputFile, filterName, options, outputFile) {
-        return new Promise((resolve, reject) => {
-            const filterChain = this.getFilterChain(filterName, options);
-            if (!filterChain) {
-                return reject(new Error(`Unknown filter: ${filterName}`));
+        return new Promise(async (resolve, reject) => {
+            try {
+                const filterChain = this.getFilterChain(filterName, options);
+                if (!filterChain) {
+                    return reject(new Error(`Unknown filter: ${filterName}`));
+                }
+
+                let bitrateKbps;
+                
+                // If bitrate is null, auto-detect from input file
+                if (this.bitrate === null) {
+                    let audioInfo = null;
+                    try {
+                        audioInfo = await this.getAudioInfo(inputFile);
+                    } catch (err) {
+                        console.warn('Could not get audio info for filter, using 128k default:', err.message);
+                    }
+                    bitrateKbps = audioInfo ? Math.floor(audioInfo.bitrate / 1000) + 'k' : '128k';
+                } else {
+                    // Use configured default bitrate
+                    bitrateKbps = Math.floor(this.bitrate / 1000) + 'k';
+                }
+
+                const command = ffmpeg()
+                    .input(inputFile)
+                    .audioFilters(filterChain)
+                    .audioCodec('libmp3lame')
+                    .audioBitrate(bitrateKbps)
+                    .format('mp3')
+                    .output(outputFile);
+
+                command
+                    .on('end', () => resolve())
+                    .on('error', (err) => reject(err))
+                    .run();
+            } catch (err) {
+                reject(err);
             }
+        });
+    }
 
-            ffmpeg()
-                .input(inputFile)
-                .audioFilters(filterChain)
-                .audioCodec('libmp3lame')
-                .format('mp3')
-                .output(outputFile)
-                .on('end', () => resolve())
-                .on('error', (err) => reject(err))
-                .run();
+    applyTrim(inputFile, options, outputFile) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                // Default options for silenceremove filter
+                // start_periods: number of silence periods at start to remove (1 = remove silence from start)
+                // start_duration: minimum duration of silence to detect at start (in seconds)
+                // start_threshold: noise tolerance for start (in dB, e.g., -50dB)
+                // stop_periods: number of silence periods at end to remove (-1 = remove all silence from end)
+                // stop_duration: minimum duration of silence to detect at end (in seconds)
+                // stop_threshold: noise tolerance for end (in dB)
+                // paddingStart: milliseconds of silence to add at the start (after removing silence)
+                // paddingEnd: milliseconds of silence to add at the end (after removing silence)
+                
+                const startPeriods = options.startPeriods !== undefined ? options.startPeriods : 1;
+                const startDuration = options.startDuration !== undefined ? options.startDuration : 0;
+                const startThreshold = options.startThreshold !== undefined ? options.startThreshold : -50;
+                const stopPeriods = options.stopPeriods !== undefined ? options.stopPeriods : -1;
+                const stopDuration = options.stopDuration !== undefined ? options.stopDuration : 0;
+                const stopThreshold = options.stopThreshold !== undefined ? options.stopThreshold : -50;
+                const paddingStart = options.paddingStart || 0; // in milliseconds
+                const paddingEnd = options.paddingEnd || 0; // in milliseconds
+
+                // Build filter chain
+                const filters = [];
+                
+                // Add silenceremove filter
+                filters.push(`silenceremove=start_periods=${startPeriods}:start_duration=${startDuration}:start_threshold=${startThreshold}dB:stop_periods=${stopPeriods}:stop_duration=${stopDuration}:stop_threshold=${stopThreshold}dB`);
+                
+                // Add padding at start if specified
+                if (paddingStart > 0) {
+                    filters.push(`adelay=${paddingStart}|${paddingStart}`);
+                }
+                
+                // Add padding at end if specified
+                if (paddingEnd > 0) {
+                    const paddingSec = paddingEnd / 1000;
+                    filters.push(`apad=pad_dur=${paddingSec}`);
+                }
+
+                const filterChain = filters.join(',');
+
+                let bitrateKbps;
+                
+                // If bitrate is null, auto-detect from input file
+                if (this.bitrate === null) {
+                    let audioInfo = null;
+                    try {
+                        audioInfo = await this.getAudioInfo(inputFile);
+                    } catch (err) {
+                        console.warn('Could not get audio info for trim, using 128k default:', err.message);
+                    }
+                    bitrateKbps = audioInfo ? Math.floor(audioInfo.bitrate / 1000) + 'k' : '128k';
+                } else {
+                    // Use configured default bitrate
+                    bitrateKbps = Math.floor(this.bitrate / 1000) + 'k';
+                }
+
+                const command = ffmpeg()
+                    .input(inputFile)
+                    .audioFilters(filterChain)
+                    .audioCodec('libmp3lame')
+                    .audioBitrate(bitrateKbps)
+                    .format('mp3')
+                    .output(outputFile);
+
+                command
+                    .on('end', () => resolve())
+                    .on('error', (err) => reject(err))
+                    .run();
+            } catch (err) {
+                reject(err);
+            }
         });
     }
 
     getFilterChain(filterName, options) {
         switch (filterName) {
             case 'normalize':
-                // Normalize audio using loudnorm filter with parameters
-                const tp = options.tp || -3;
-                const i = options.i || -20;
-                const lra = options.lra || 11;
-                return `loudnorm=I=${i}:TP=${tp}:LRA=${lra}:print_format=none`;
+                // Normalize audio using dynaudnorm filter which is more robust
+                // tp parameter is converted to target peak (p parameter, range 0-1)
+                // Default tp of -1.5 dB corresponds to approximately 0.95 peak
+                const tp = options.tp || -1.5;
+                const targetPeak = Math.pow(10, tp / 20); // Convert dB to linear scale
+                const p = Math.min(0.99, Math.max(0.5, targetPeak));
+                return `dynaudnorm=p=${p.toFixed(2)}:m=100:s=10`;
 
             case 'telephone':
                 // Telephone effect with parameters

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "sfxmix",
     "description": "🎧 SfxMix - Powerful and easy-to-use module for processing audio.",
-    "version": "1.2.8",
+    "version": "1.3.2",
     "main": "index.js",
     "dependencies": {
         "fluent-ffmpeg": "^2.1.3",
@@ -29,6 +29,7 @@
         "phaser",
         "compressor",
         "flanger",
+        "trim",
         "reverb",
         "highpass",
         "lowpass",