sfxmix 1.4.6 → 1.5.2

package/demo/demo_9.js

@@ -0,0 +1,40 @@
+import SfxMix from '../index.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+async function main() {
+    const sfx = new SfxMix();
+
+    const evalDir = path.join(__dirname, 'eval');
+    const files = [
+        'everyo_collap_en_us_secyut_1y7pqko.mp3',
+        'theyre_callin_it_a_sudden_208g2a.mp3',
+        'were_on_cnn_too_en_us_secyut_ve1xs.mp3'
+    ];
+
+    console.log('=== Truncation Detection Test ===\n');
+
+    for (const file of files) {
+        const filePath = path.join(evalDir, file);
+        try {
+            const result = await sfx.add(filePath).isTruncated();
+            console.log(`File: ${file}`);
+            console.log(`  Truncated:  ${result.truncated}`);
+            console.log(`  Tail RMS:   ${result.tailRmsDb} dB`);
+            console.log(`  Tail Peak:  ${result.tailPeakDb} dB`);
+            console.log(`  Duration:   ${result.duration}s`);
+            console.log(`  Threshold:  ${result.threshold} dB`);
+            console.log(`  Tail analyzed: ${result.tailDuration} ms`);
+            console.log('');
+        } catch (err) {
+            console.error(`Error analyzing ${file}:`, err.message);
+        }
+    }
+
+    sfx.cleanup();
+}
+
+main();

package/index.js

@@ -131,77 +131,79 @@ class SfxMix {
         return this.convertAudio(inputFile, outputFile, options);
     }
 
+    async _processActions() {
+        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 = this.getTempFile('concat');
+                    await this.concatenateAudioFiles([this.currentFile, action.input], tempFile);
+                    if (this.isTempFile(this.currentFile)) {
+                        this.safeDeleteFile(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 = this.getTempFile('mix');
+                await this.mixAudioFiles(this.currentFile, action.input, tempFile, action.options);
+                if (this.isTempFile(this.currentFile)) {
+                    this.safeDeleteFile(this.currentFile);
+                }
+                this.currentFile = tempFile;
+            } else if (action.type === 'silence') {
+                const tempSilenceFile = this.getTempFile('silence');
+                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 {
+                    const tempFile = this.getTempFile('concat');
+                    await this.concatenateAudioFiles([this.currentFile, tempSilenceFile], tempFile);
+                    if (this.isTempFile(this.currentFile)) {
+                        this.safeDeleteFile(this.currentFile);
+                    }
+                    this.safeDeleteFile(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 = this.getTempFile('filter');
+                await this.applyFilter(this.currentFile, action.filterName, action.options, tempFile);
+                if (this.isTempFile(this.currentFile)) {
+                    this.safeDeleteFile(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 = this.getTempFile('trim');
+                await this.applyTrim(this.currentFile, action.options, tempFile);
+                if (this.isTempFile(this.currentFile)) {
+                    this.safeDeleteFile(this.currentFile);
+                }
+                this.currentFile = tempFile;
+            }
+        }
+    }
+
     save(output, outputOptions = {}) {
         return new Promise(async (resolve, reject) => {
             try {
-                // Process all actions
-                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 = this.getTempFile('concat');
-                            await this.concatenateAudioFiles([this.currentFile, action.input], tempFile);
-                            if (this.isTempFile(this.currentFile)) {
-                                this.safeDeleteFile(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 = this.getTempFile('mix');
-                        await this.mixAudioFiles(this.currentFile, action.input, tempFile, action.options);
-                        if (this.isTempFile(this.currentFile)) {
-                            this.safeDeleteFile(this.currentFile);
-                        }
-                        this.currentFile = tempFile;
-                    } else if (action.type === 'silence') {
-                        const tempSilenceFile = this.getTempFile('silence');
-                        // 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 {
-                            const tempFile = this.getTempFile('concat');
-                            await this.concatenateAudioFiles([this.currentFile, tempSilenceFile], tempFile);
-                            if (this.isTempFile(this.currentFile)) {
-                                this.safeDeleteFile(this.currentFile);
-                            }
-                            this.safeDeleteFile(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 = this.getTempFile('filter');
-                        await this.applyFilter(this.currentFile, action.filterName, action.options, tempFile);
-                        if (this.isTempFile(this.currentFile)) {
-                            this.safeDeleteFile(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 = this.getTempFile('trim');
-                        await this.applyTrim(this.currentFile, action.options, tempFile);
-                        if (this.isTempFile(this.currentFile)) {
-                            this.safeDeleteFile(this.currentFile);
-                        }
-                        this.currentFile = tempFile;
-                    }
-                }
+                await this._processActions();
                 
                 // Prepare output
                 const absoluteOutput = path.resolve(process.cwd(), output);
@@ -368,6 +370,111 @@ class SfxMix {
         });
     }
 
+    /**
+     * Check if the current audio is truncated (doesn't end in silence).
+     * Terminal operation: processes the action chain, analyzes the tail of the
+     * resulting audio, then resets. Use after .add() like any other terminal op.
+     * 
+     * @param {Object} options - Analysis options
+     * @param {number} options.tailDuration - Milliseconds of audio tail to analyze (default: 50)
+     * @param {number} options.threshold - dB threshold; above this = truncated (default: -30)
+     * @returns {Promise<Object>} Result with truncated flag and audio metrics
+     */
+    isTruncated(options = {}) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                await this._processActions();
+
+                if (!this.currentFile) {
+                    throw new Error('No audio to analyze. Add audio before checking truncation.');
+                }
+
+                const result = await this._analyzeTail(this.currentFile, options);
+
+                // Clean up temp files
+                if (this.isTempFile(this.currentFile)) {
+                    this.safeDeleteFile(this.currentFile);
+                }
+                this.reset();
+                resolve(result);
+            } catch (err) {
+                if (this.currentFile && this.isTempFile(this.currentFile)) {
+                    this.safeDeleteFile(this.currentFile);
+                }
+                this.reset();
+                reject(err);
+            }
+        });
+    }
+
+    _analyzeTail(filePath, options = {}) {
+        return new Promise((resolve, reject) => {
+            const tailDuration = options.tailDuration || 50;
+            const threshold = options.threshold !== undefined ? options.threshold : -30;
+            const sampleRate = 44100;
+            const tailSamples = Math.floor((tailDuration / 1000) * sampleRate);
+
+            const chunks = [];
+
+            const stream = ffmpeg(filePath)
+                .audioChannels(1)
+                .audioFrequency(sampleRate)
+                .format('s16le')
+                .on('error', err => reject(err))
+                .pipe();
+
+            stream.on('data', chunk => chunks.push(chunk));
+
+            stream.on('end', () => {
+                const buffer = Buffer.concat(chunks);
+                const allSamples = new Int16Array(
+                    buffer.buffer,
+                    buffer.byteOffset,
+                    Math.floor(buffer.length / 2)
+                );
+
+                const duration = allSamples.length / sampleRate;
+
+                if (allSamples.length === 0) {
+                    return resolve({
+                        truncated: false,
+                        tailRmsDb: -Infinity,
+                        tailPeakDb: -Infinity,
+                        duration: 0,
+                        threshold,
+                        tailDuration
+                    });
+                }
+
+                const startIdx = Math.max(0, allSamples.length - tailSamples);
+                const samples = allSamples.slice(startIdx);
+
+                let sumSquares = 0;
+                let peak = 0;
+                for (let i = 0; i < samples.length; i++) {
+                    const normalized = samples[i] / 32768;
+                    sumSquares += normalized * normalized;
+                    peak = Math.max(peak, Math.abs(normalized));
+                }
+
+                const rms = Math.sqrt(sumSquares / samples.length);
+                const rmsDb = rms > 0 ? 20 * Math.log10(rms) : -Infinity;
+                const peakDb = peak > 0 ? 20 * Math.log10(peak) : -Infinity;
+
+                resolve({
+                    truncated: rmsDb > threshold,
+                    tailRmsDb: Math.round(rmsDb * 100) / 100,
+                    tailPeakDb: Math.round(peakDb * 100) / 100,
+                    duration: Math.round(duration * 1000) / 1000,
+                    threshold,
+                    tailDuration
+                });
+            });
+
+            stream.on('error', err => reject(err));
+        });
+    }
+
     getAudioInfo(inputFile) {
         return new Promise((resolve, reject) => {
             ffmpeg.ffprobe(inputFile, (err, metadata) => {
@@ -490,13 +597,13 @@ class SfxMix {
                 // stopDuration: min duration of non-silence to stop trimming at end (in seconds).
                 //   Default 0.05s (50ms) to skip short noise artifacts/blips at the end that would prevent proper trimming.
                 // stopThreshold: noise tolerance for end (in dB, e.g., -50dB). Higher values (e.g. -20) are more aggressive.
-                // paddingStart: milliseconds of silence to add at the start (after removing silence)
-                // paddingEnd: milliseconds of silence to add at the end (after removing silence)
+                // paddingStart: milliseconds of original audio to preserve at the start (after the silence boundary)
+                // paddingEnd: milliseconds of original audio to preserve at the end (after the silence boundary)
                 
                 const startDuration = options.startDuration !== undefined ? options.startDuration : 0;
-                const startThreshold = options.startThreshold !== undefined ? options.startThreshold : -50;
+                const startThreshold = options.startThreshold !== undefined ? options.startThreshold : -30;
                 const stopDuration = options.stopDuration !== undefined ? options.stopDuration : 0.05;
-                const stopThreshold = options.stopThreshold !== undefined ? options.stopThreshold : -50;
+                const stopThreshold = options.stopThreshold !== undefined ? options.stopThreshold : -30;
                 const paddingStart = options.paddingStart || 0; // in milliseconds
                 const paddingEnd = options.paddingEnd || 0; // in milliseconds
 
@@ -521,28 +628,19 @@ class SfxMix {
                 // This ensures we ONLY remove silence from the beginning and end, preserving intermediate silences
                 const filters = [];
                 
-                // Remove silence from the start
-                filters.push(`silenceremove=start_periods=1:start_duration=${startDuration}:start_threshold=${startThreshold}dB:detection=peak`);
+                // Remove silence from the start, preserving paddingStart ms of original audio if specified
+                const startSilenceParam = paddingStart > 0 ? `:start_silence=${paddingStart / 1000}` : '';
+                filters.push(`silenceremove=start_periods=1:start_duration=${startDuration}:start_threshold=${startThreshold}dB${startSilenceParam}:detection=peak`);
                 
                 // Reverse the audio
                 filters.push('areverse');
                 
-                // Remove silence from what is now the start (but was the end)
-                filters.push(`silenceremove=start_periods=1:start_duration=${stopDuration}:start_threshold=${stopThreshold}dB:detection=peak`);
+                // Remove silence from what is now the start (but was the end), preserving paddingEnd ms of original audio if specified
+                const endSilenceParam = paddingEnd > 0 ? `:start_silence=${paddingEnd / 1000}` : '';
+                filters.push(`silenceremove=start_periods=1:start_duration=${stopDuration}:start_threshold=${stopThreshold}dB${endSilenceParam}:detection=peak`);
                 
                 // Reverse back to original direction
                 filters.push('areverse');
-                
-                // 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}`);
-                }
 
                 // CRITICAL: Resample at the end to fix "inadequate AVFrame plane padding" error
                 // This regenerates the audio frames with proper padding for the encoder

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "sfxmix",
     "description": "🎧 SfxMix - Powerful and easy-to-use module for processing audio.",
-    "version": "1.4.6",
+    "version": "1.5.2",
     "main": "index.js",
     "dependencies": {
         "fluent-ffmpeg": "^2.1.3"