streamify-audio 2.2.2 → 2.2.6

package/src/discord/Stream.js

@@ -21,7 +21,16 @@ class StreamController {
         this.resource = null;
         this.destroyed = false;
         this.startTime = null;
-        this.bytesReceived = 0;
+        this.ytdlpError = '';
+        this.ffmpegError = '';
+        
+        // Timing metrics
+        this.metrics = {
+            metadata: 0,
+            spawn: 0,
+            firstByte: 0,
+            total: 0
+        };
     }
 
     async create(seekPosition = 0) {
@@ -34,20 +43,25 @@ class StreamController {
         }
 
         this.startTime = Date.now();
+        const startTimestamp = this.startTime;
         const source = this.track.source || 'youtube';
 
         let videoId = this.track._resolvedId || this.track.id;
 
+        // Skip metadata resolution if we already have it
         if (source === 'spotify' && !this.track._resolvedId) {
             log.info('STREAM', `Resolving Spotify track to YouTube: ${this.track.title}`);
             try {
                 const spotify = require('../providers/spotify');
                 videoId = await spotify.resolveToYouTube(this.track.id, this.config);
                 this.track._resolvedId = videoId;
+                this.metrics.metadata = Date.now() - startTimestamp;
             } catch (error) {
                 log.error('STREAM', `Spotify resolution failed: ${error.message}`);
                 throw new Error(`Failed to resolve Spotify track: ${error.message}`);
             }
+        } else {
+            this.metrics.metadata = 0; // Already resolved
         }
 
         if (!videoId || videoId === 'undefined') {
@@ -55,197 +69,250 @@ class StreamController {
         }
 
         log.info('STREAM', `Creating stream for ${videoId} (${source})`);
-
-        let url;
-        if (source === 'soundcloud') {
-            url = this.track.uri || `https://api.soundcloud.com/tracks/${videoId}/stream`;
-        } else {
-            url = `https://www.youtube.com/watch?v=${videoId}`;
+        
+        // Log Filter Chain Trace (No data impact)
+        const filterNames = Object.keys(this.filters).filter(k => k !== 'start' && k !== '_trigger' && k !== 'volume');
+        if (filterNames.length > 0) {
+            const chain = filterNames.map(name => {
+                const val = this.filters[name];
+                let displayVal = typeof val === 'object' ? JSON.stringify(val) : val;
+                if (displayVal === true || displayVal === 'true') displayVal = 'ON';
+                return `[${name.toUpperCase()} (${displayVal})]`;
+            }).join(' ➔ ');
+            log.info('STREAM', `Filter Chain: ${chain}`);
         }
 
         const isYouTube = source === 'youtube' || source === 'spotify';
         const isLive = this.track.isLive === true || this.track.duration === 0;
-
-        let formatString;
-        if (isLive) {
-            formatString = 'bestaudio*/best';
+        const isLocal = source === 'local';
+
+        let ytdlp;
+        let ffmpegIn;
+
+        const env = { ...process.env, PATH: '/usr/local/bin:/root/.deno/bin:' + process.env.PATH };
+        const spawnStart = Date.now();
+
+        if (isLocal) {
+            // Skip yt-dlp for local files
+            ffmpegIn = 'pipe:0'; // We'll just pass the file path to ffmpeg -i
+            this.metrics.spawn = Date.now() - spawnStart;
+        } else if (this.track._directUrl && !isLive && seekPosition === 0) {
+            // OPTIMIZATION: Bypass yt-dlp if we already have a direct stream URL
+            ffmpegIn = this.track._directUrl;
+            log.info('STREAM', `Bypassing yt-dlp, using direct URL for ${videoId}`);
+            this.metrics.spawn = 0;
         } else {
-            formatString = isYouTube ? '18/22/bestaudio[ext=webm]/bestaudio/best' : 'bestaudio/best';
-        }
-
-        const ytdlpArgs = [
-            '-f', formatString,
-            '--no-playlist',
-            '--no-check-certificates',
-            '--no-warnings',
-            '--retries', '3',
-            '--fragment-retries', '3',
-            '-o', '-',
-            url
-        ];
-
-        if (isLive) {
-            ytdlpArgs.push('--no-live-from-start');
-            log.info('STREAM', `Live stream detected, using live-compatible format`);
-        } else if (isYouTube) {
-            ytdlpArgs.push('--extractor-args', 'youtube:player_client=web_creator');
-        }
+            let url;
+            if (source === 'soundcloud') {
+                url = this.track.uri || `https://api.soundcloud.com/tracks/${videoId}/stream`;
+            } else if (['twitch', 'mixcloud', 'bandcamp', 'http'].includes(source)) {
+                url = this.track.uri || videoId;
+            } else {
+                url = `https://www.youtube.com/watch?v=${videoId}`;
+            }
 
-        if (seekPosition > 0) {
-            const seekSeconds = Math.floor(seekPosition / 1000);
-            ytdlpArgs.push('--download-sections', `*${seekSeconds}-`);
-            log.info('STREAM', `Seeking to ${seekSeconds}s`);
-        }
+            let formatString;
+            if (isLive) {
+                formatString = 'bestaudio*/best';
+            } else {
+                formatString = this.config.ytdlp.format;
+            }
 
-        if (this.config.cookiesPath) {
-            ytdlpArgs.unshift('--cookies', this.config.cookiesPath);
-        }
+            const ytdlpArgs = [
+                '-f', formatString,
+                '--no-playlist',
+                '--no-check-certificates',
+                '--no-warnings',
+                '--no-cache-dir',
+                '--no-mtime',
+                '--buffer-size', '16K',
+                '--quiet',
+                '--retries', '3',
+                '--fragment-retries', '3',
+                '-o', '-',
+                ...this.config.ytdlp.additionalArgs,
+                url
+            ];
+
+            if (isLive) {
+                ytdlpArgs.push('--no-live-from-start');
+            } else if (isYouTube) {
+                ytdlpArgs.push('--extractor-args', 'youtube:player_client=web_creator');
+            }
 
-        if (this.config.sponsorblock?.enabled !== false && isYouTube) {
-            const categories = this.config.sponsorblock?.categories || ['sponsor', 'selfpromo'];
-            ytdlpArgs.push('--sponsorblock-remove', categories.join(','));
-        }
+            if (seekPosition > 0) {
+                const seekSeconds = Math.floor(seekPosition / 1000);
+                ytdlpArgs.push('--download-sections', `*${seekSeconds}-`);
+                log.info('STREAM', `Seeking to ${seekSeconds}s`);
+            }
 
-        this.ytdlp = spawn(this.config.ytdlpPath, ytdlpArgs, {
-            env: { ...process.env, PATH: '/usr/local/bin:/root/.deno/bin:' + process.env.PATH }
-        });
+            if (this.config.cookiesPath) {
+                ytdlpArgs.unshift('--cookies', this.config.cookiesPath);
+            }
 
-        this._spawnTime = Date.now() - this.startTime;
+            if (this.config.sponsorblock?.enabled !== false && isYouTube) {
+                const categories = this.config.sponsorblock?.categories || ['sponsor', 'selfpromo'];
+                ytdlpArgs.push('--sponsorblock-remove', categories.join(','));
+            }
 
-        const ffmpegFilters = { ...this.filters };
-        if (seekPosition > 0) {
-            ffmpegFilters.start = seekPosition / 1000;
+            this.ytdlp = spawn(this.config.ytdlpPath, ytdlpArgs, { env });
+            ffmpegIn = 'pipe:0';
         }
 
+        const ffmpegFilters = { ...this.filters };
         const ffmpegArgs = buildFfmpegArgs(ffmpegFilters, this.config);
-        this.ffmpeg = spawn(this.config.ffmpegPath, ffmpegArgs);
-
-        this._firstDataTime = null;
-        this.ytdlp.stdout.on('data', (chunk) => {
-            if (!this._firstDataTime) {
-                this._firstDataTime = Date.now() - this.startTime;
+        
+        // Input injection - only override if NOT using pipe:0 (buildFfmpegArgs already includes -i pipe:0)
+        if (isLocal) {
+            const filePath = this.track.absolutePath || videoId.replace('file://', '');
+            const pipeIndex = ffmpegArgs.indexOf('pipe:0');
+            if (pipeIndex > 0) {
+                ffmpegArgs[pipeIndex] = filePath;
+                if (seekPosition > 0) {
+                    const seekSeconds = (seekPosition / 1000).toFixed(3);
+                    ffmpegArgs.splice(pipeIndex - 1, 0, '-ss', seekSeconds);
+                }
             }
-            this.bytesReceived += chunk.length;
-        });
-
-        this.ytdlp.stdout.pipe(this.ffmpeg.stdin);
-
-        let ytdlpError = '';
-        this.ytdlp.stderr.on('data', (data) => {
-            if (this.destroyed) return;
-            const msg = data.toString();
-            ytdlpError += msg;
-            if (msg.includes('ERROR:') && !msg.includes('Retrying') && !msg.includes('Broken pipe')) {
-                log.error('YTDLP', msg.trim());
-            } else if (!msg.includes('[download]') && !msg.includes('ETA') && !msg.includes('[youtube]') && !msg.includes('Retrying fragment') && !msg.includes('Got error')) {
-                log.debug('YTDLP', msg.trim());
+        } else if (ffmpegIn !== 'pipe:0') {
+            // Direct URL - replace the pipe:0 input with the direct URL
+            const pipeIndex = ffmpegArgs.indexOf('pipe:0');
+            if (pipeIndex > 0) {
+                ffmpegArgs[pipeIndex] = ffmpegIn;
+                if (this.track._headers) {
+                    const headers = Object.entries(this.track._headers)
+                        .map(([k, v]) => `${k}: ${v}`)
+                        .join('\r\n');
+                    ffmpegArgs.splice(pipeIndex - 1, 0, '-headers', headers);
+                }
             }
-        });
+        }
+        // else: pipe:0 - buildFfmpegArgs already has -i pipe:0, nothing to change
+
+        this.ffmpeg = spawn(this.config.ffmpegPath, ffmpegArgs, { env });
+        this.metrics.spawn = Date.now() - spawnStart;
+
+        if (this.ytdlp) {
+            this.ytdlp.stdout.pipe(this.ffmpeg.stdin);
+
+            this.ytdlp.stderr.on('data', (data) => {
+                if (this.destroyed) return;
+                const msg = data.toString();
+                this.ytdlpError += msg;
+                if (msg.includes('ERROR:') && !msg.includes('Retrying') && !msg.includes('Broken pipe')) {
+                    log.error('YTDLP', msg.trim());
+                } else if (!msg.includes('[download]') && !msg.includes('ETA') && !msg.includes('[youtube]') && !msg.includes('Retrying fragment') && !msg.includes('Got error')) {
+                    log.debug('YTDLP', msg.trim());
+                }
+            });
+
+            this.ytdlp.on('close', (code) => {
+                if (code !== 0 && code !== null && !this.destroyed) {
+                    log.error('STREAM', `yt-dlp failed (code: ${code}) for ${videoId}`);
+                }
+                if (this.ffmpeg && !this.ffmpeg.killed && this.ffmpeg.stdin) {
+                    try { this.ffmpeg.stdin.end(); } catch(e) {}
+                }
+            });
+        }
 
         this.ffmpeg.stderr.on('data', (data) => {
             if (this.destroyed) return;
             const msg = data.toString();
+            this.ffmpegError += msg;
             if ((msg.includes('Error') || msg.includes('error')) && !msg.includes('Connection reset') && !msg.includes('Broken pipe')) {
                 log.error('FFMPEG', msg.trim());
             }
         });
 
-        this.ytdlp.on('close', (code) => {
-            if (code !== 0 && code !== null && !this.destroyed) {
-                log.error('STREAM', `yt-dlp failed (code: ${code}) for ${videoId}`);
-                if (ytdlpError) {
-                    log.error('STREAM', `yt-dlp stderr: ${ytdlpError.slice(-500)}`);
-                }
-            }
-            if (this.ffmpeg && !this.ffmpeg.killed) {
-                this.ffmpeg.stdin.end();
-            }
-        });
-
-        this.ytdlp.on('error', (error) => {
-            if (error.code !== 'EPIPE' && !this.destroyed) {
-                log.error('STREAM', `yt-dlp spawn error: ${error.message}`);
-            }
-        });
-
-        this.ffmpeg.on('error', (error) => {
-            if (error.code !== 'EPIPE' && !this.destroyed) {
-                log.error('STREAM', `ffmpeg spawn error: ${error.message}`);
-            }
-        });
-
-        this.ytdlp.stdout.on('error', (error) => {
-            if (error.code !== 'EPIPE' && !this.destroyed) {
-                log.debug('STREAM', `yt-dlp stdout error: ${error.message}`);
-            }
-        });
-
-        this.ffmpeg.stdin.on('error', (error) => {
-            if (error.code !== 'EPIPE' && !this.destroyed) {
-                log.debug('STREAM', `ffmpeg stdin error: ${error.message}`);
-            }
-        });
-
-        this.ffmpeg.stdout.on('error', (error) => {
-            if (error.code !== 'EPIPE' && !this.destroyed) {
-                log.debug('STREAM', `ffmpeg stdout error: ${error.message}`);
-            }
-        });
-
         await this._waitForData(isLive);
 
+        if (this.destroyed || !this.ffmpeg) {
+            throw new Error('Stream destroyed during initialization');
+        }
+
         this.resource = createAudioResource(this.ffmpeg.stdout, {
             inputType: StreamType.OggOpus,
             inlineVolume: false
         });
 
-        const elapsed = Date.now() - this.startTime;
-        const firstData = this._firstDataTime || elapsed;
-        log.info('STREAM', `Ready ${elapsed}ms | First byte: ${firstData}ms | Buffered: ${this.bytesReceived}`);
+        const elapsed = Date.now() - startTimestamp;
+        this.metrics.total = elapsed;
+        
+        log.info('STREAM', `Ready ${elapsed}ms | Metrics: [Metadata: ${this.metrics.metadata}ms | Spawn: ${this.metrics.spawn}ms | FirstByte: ${this.metrics.firstByte}ms]`);
 
         return this.resource;
     }
 
     _waitForData(isLive = false) {
+        const ffmpeg = this.ffmpeg;
+        const ytdlp = this.ytdlp;
+        const MIN_BUFFER_SIZE = 32 * 1024;
+
         return new Promise((resolve, reject) => {
+            if (!ffmpeg) return resolve();
+
             const timeoutMs = isLive ? 30000 : 15000;
             const timeout = setTimeout(() => {
-                log.warn('STREAM', `Timeout waiting for data, proceeding anyway (received: ${this.bytesReceived}, isLive: ${isLive})`);
+                log.warn('STREAM', `Timeout waiting for data, proceeding anyway`);
                 resolve();
             }, timeoutMs);
 
             let resolved = false;
+            let bufferedSize = 0;
+            let firstByteRecorded = false;
+
+            const checkBuffer = () => {
+                if (resolved) return;
 
-            const checkInterval = setInterval(() => {
-                if (resolved) {
-                    clearInterval(checkInterval);
-                    return;
+                if (!firstByteRecorded && ffmpeg.stdout && ffmpeg.stdout.readableLength > 0) {
+                    firstByteRecorded = true;
+                    this.metrics.firstByte = Date.now() - (this.startTime + this.metrics.metadata + this.metrics.spawn);
                 }
-                if (this.bytesReceived > 0) {
+
+                bufferedSize = ffmpeg.stdout ? ffmpeg.stdout.readableLength : 0;
+
+                if (bufferedSize >= MIN_BUFFER_SIZE) {
                     resolved = true;
                     clearTimeout(timeout);
-                    clearInterval(checkInterval);
+                    if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', checkBuffer);
                     resolve();
                 }
-            }, 50);
+            };
 
-            this.ffmpeg.on('close', () => {
+            if (ffmpeg.stdout) {
+                ffmpeg.stdout.on('readable', checkBuffer);
+            }
+
+            ffmpeg.on('close', () => {
                 if (!resolved) {
                     resolved = true;
                     clearTimeout(timeout);
-                    clearInterval(checkInterval);
-                    reject(new Error('ffmpeg closed before producing data'));
-                }
-            });
+                    if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', checkBuffer);
 
-            this.ytdlp.on('close', (code) => {
-                if (!resolved && code !== 0) {
-                    resolved = true;
-                    clearTimeout(timeout);
-                    clearInterval(checkInterval);
-                    reject(new Error(`yt-dlp failed with code ${code}`));
+                    if (this.destroyed) {
+                        return reject(new Error('Stream destroyed during initialization'));
+                    }
+
+                    const sourceErr = ytdlp ? `yt-dlp stderr: ${this.ytdlpError.slice(-200) || 'none'}` : `ffmpeg stderr: ${this.ffmpegError.slice(-200) || 'none'}`;
+                    reject(new Error(`ffmpeg closed before producing data. ${sourceErr}`));
                 }
             });
+
+            if (ytdlp) {
+                ytdlp.on('close', (code) => {
+                    if (!resolved && code !== 0 && code !== null) {
+                        resolved = true;
+                        clearTimeout(timeout);
+                        if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', checkBuffer);
+
+                        if (this.destroyed) {
+                            return reject(new Error('Stream destroyed during initialization'));
+                        }
+
+                        reject(new Error(`yt-dlp failed with code ${code}`));
+                    }
+                });
+            }
         });
     }
 
@@ -254,7 +321,7 @@ class StreamController {
         this.destroyed = true;
 
         const elapsed = this.startTime ? Date.now() - this.startTime : 0;
-        log.info('STREAM', `Destroying stream | Duration: ${elapsed}ms | Received: ${this.bytesReceived}`);
+        log.info('STREAM', `Destroying stream | Duration: ${Math.floor(elapsed / 1000)}s`);
 
         try {
             if (this.ytdlp && this.ffmpeg) {
@@ -287,4 +354,4 @@ function createStream(track, filters, config) {
     return new StreamController(track, filters, config);
 }
 
-module.exports = { createStream, StreamController };
+module.exports = { createStream, StreamController };

package/src/filters/ffmpeg.js

@@ -15,7 +15,38 @@ const PRESETS = {
     piano: [0.2, 0.15, 0.1, 0.05, 0, 0.05, 0.1, 0.15, 0.2, 0.2, 0.15, 0.1, 0.1, 0.15, 0.2],
     vocal: [-0.2, -0.15, -0.1, 0, 0.2, 0.35, 0.4, 0.4, 0.35, 0.2, 0, -0.1, -0.15, -0.15, -0.1],
     bass_heavy: [0.5, 0.45, 0.4, 0.3, 0.2, 0.1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-    treble_heavy: [0, 0, 0, 0, 0, 0, 0, 0, 0.1, 0.2, 0.3, 0.4, 0.45, 0.5, 0.5]
+    treble_heavy: [0, 0, 0, 0, 0, 0, 0, 0, 0.1, 0.2, 0.3, 0.4, 0.45, 0.5, 0.5],
+    extra_bass: [0.6, 0.55, 0.5, 0.4, 0.3, 0.2, 0.1, 0, 0, 0, 0, 0, 0, 0, 0],
+    crystal_clear: [-0.1, -0.1, -0.05, 0, 0.1, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.5, 0.5, 0.5]
+};
+
+const EFFECT_PRESETS = {
+    bassboost: { filters: { bass: 12, equalizer: [0.4, 0.3, 0.2, 0.1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] }, description: 'Heavy bass boost' },
+    nightcore: { filters: { speed: 1.25, pitch: 1.25 }, description: 'Speed up with higher pitch' },
+    vaporwave: { filters: { speed: 0.8, pitch: 0.8 }, description: 'Slow down with lower pitch' },
+    '8d': { filters: { rotation: { speed: 0.15 } }, description: '8D rotating audio effect' },
+    karaoke: { filters: { karaoke: true }, description: 'Reduce vocals' },
+    trebleboost: { filters: { treble: 10 }, description: 'Boost treble frequencies' },
+    deep: { filters: { bass: 15, pitch: 0.85, equalizer: [0.5, 0.4, 0.3, 0.2, 0.1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] }, description: 'Deep bass with lower pitch' },
+    lofi: { filters: { lowpass: 2500, bass: 8, treble: -5 }, description: 'Lo-fi aesthetic' },
+    radio: { filters: { highpass: 400, lowpass: 4500, compressor: true }, description: 'Radio/telephone effect' },
+    telephone: { filters: { highpass: 600, lowpass: 3000, compressor: true }, description: 'Old telephone effect' },
+    soft: { filters: { bass: -3, treble: -5, volume: 80, compressor: true }, description: 'Softer, compressed sound' },
+    loud: { filters: { bass: 3, treble: 2, volume: 120, compressor: true, normalizer: true }, description: 'Louder, punchier sound' },
+    chipmunk: { filters: { pitch: 1.6 }, description: 'High-pitched chipmunk voice' },
+    darth: { filters: { pitch: 0.65 }, description: 'Deep Darth Vader voice' },
+    echo: { filters: { echo: true }, description: 'Echo/reverb effect' },
+    vibrato: { filters: { vibrato: { frequency: 6, depth: 0.6 } }, description: 'Vibrato effect' },
+    tremolo: { filters: { tremolo: { frequency: 5, depth: 0.5 } }, description: 'Tremolo effect' },
+    reverb: { filters: { reverb: true }, description: 'Classic reverb effect' },
+    surround: { filters: { surround: true }, description: 'Surround sound effect' },
+    boost: { filters: { volume: 150, treble: 5, bass: 5, compressor: true }, description: 'Boost volume and clarity' },
+    subboost: { filters: { bass: 15, lowpass: 100 }, description: 'Extreme sub-woofer boost' },
+    pop: { filters: { preset: 'pop' }, description: 'Pop EQ preset' },
+    rock: { filters: { preset: 'rock' }, description: 'Rock EQ preset' },
+    electronic: { filters: { preset: 'electronic' }, description: 'Electronic EQ preset' },
+    jazz: { filters: { preset: 'jazz' }, description: 'Jazz EQ preset' },
+    classical: { filters: { preset: 'classical' }, description: 'Classical EQ preset' }
 };
 
 function buildEqualizer(bands) {
@@ -36,8 +67,18 @@ function buildEqualizer(bands) {
 }
 
 function buildFfmpegArgs(filters = {}, config = {}) {
-    const args = ['-i', 'pipe:0', '-vn'];
-    const audioFilters = [];
+    filters = filters || {};
+    const args = [
+        '-thread_queue_size', '4096',
+        '-probesize', '128K',
+        '-analyzeduration', '0',
+        '-fflags', '+discardcorrupt',
+        '-copyts',
+        '-start_at_zero',
+        '-i', 'pipe:0',
+        '-vn'
+    ];
+    const audioFilters = ['aresample=async=1:first_pts=0'];
 
     if (filters.equalizer && Array.isArray(filters.equalizer)) {
         const eq = buildEqualizer(filters.equalizer);
@@ -64,11 +105,7 @@ function buildFfmpegArgs(filters = {}, config = {}) {
     const speed = parseFloat(filters.speed);
     if (!isNaN(speed) && speed !== 1) {
         const clampedSpeed = Math.max(0.5, Math.min(2.0, speed));
-        if (clampedSpeed < 1) {
-            audioFilters.push(`atempo=${clampedSpeed}`);
-        } else if (clampedSpeed <= 2) {
-            audioFilters.push(`atempo=${clampedSpeed}`);
-        }
+        audioFilters.push(`atempo=${clampedSpeed}`);
     }
 
     const pitch = parseFloat(filters.pitch);
@@ -185,18 +222,24 @@ function buildFfmpegArgs(filters = {}, config = {}) {
         audioFilters.push('loudnorm');
     }
 
+    if (filters.echo === 'true' || filters.echo === true) {
+        audioFilters.push('aecho=0.8:0.88:60:0.4');
+    }
+
+    if (filters.reverb === 'true' || filters.reverb === true) {
+        audioFilters.push('aecho=0.8:0.88:60:0.4,aecho=0.8:0.88:30:0.2');
+    }
+
     if (filters.nightcore === 'true' || filters.nightcore === true) {
-        audioFilters.push('atempo=1.25');
-        audioFilters.push('asetrate=48000*1.25,aresample=48000');
+        audioFilters.push('atempo=1.25,asetrate=48000*1.25,aresample=48000');
     }
 
     if (filters.vaporwave === 'true' || filters.vaporwave === true) {
-        audioFilters.push('atempo=0.8');
-        audioFilters.push('asetrate=48000*0.8,aresample=48000');
+        audioFilters.push('atempo=0.8,asetrate=48000*0.8,aresample=48000');
     }
 
     if (filters.bassboost === 'true' || filters.bassboost === true) {
-        audioFilters.push('bass=g=10');
+        audioFilters.push('bass=g=10,equalizer=f=40:width_type=h:width=20:g=10');
     }
 
     if (filters['8d'] === 'true' || filters['8d'] === true) {
@@ -211,7 +254,14 @@ function buildFfmpegArgs(filters = {}, config = {}) {
     const format = config.audio?.format || 'opus';
 
     if (format === 'opus') {
-        args.push('-acodec', 'libopus', '-b:a', bitrate, '-f', 'ogg');
+        args.push(
+            '-acodec', 'libopus',
+            '-b:a', bitrate,
+            '-vbr', config.audio?.vbr !== false ? 'on' : 'off',
+            '-compression_level', (config.audio?.compressionLevel ?? 10).toString(),
+            '-application', config.audio?.application || 'audio',
+            '-f', 'ogg'
+        );
     } else if (format === 'mp3') {
         args.push('-acodec', 'libmp3lame', '-b:a', bitrate, '-f', 'mp3');
     } else if (format === 'aac') {
@@ -255,6 +305,8 @@ function getAvailableFilters() {
         nightcore: { type: 'boolean', description: 'Nightcore preset' },
         vaporwave: { type: 'boolean', description: 'Vaporwave preset' },
         bassboost: { type: 'boolean', description: 'Bass boost preset' },
+        echo: { type: 'boolean', description: 'Echo effect' },
+        reverb: { type: 'boolean', description: 'Reverb effect' },
         '8d': { type: 'boolean', description: '8D audio effect' }
     };
 }
@@ -267,4 +319,61 @@ function getEQBands() {
     return EQ_BANDS;
 }
 
-module.exports = { buildFfmpegArgs, getAvailableFilters, getPresets, getEQBands, PRESETS, EQ_BANDS };
+function getEffectPresets() {
+    return EFFECT_PRESETS;
+}
+
+function getEffectPresetsInfo() {
+    return Object.entries(EFFECT_PRESETS).map(([name, data]) => ({
+        name,
+        description: data.description,
+        filters: Object.keys(data.filters)
+    }));
+}
+
+function applyEffectPreset(name, intensity = 1.0) {
+    const preset = EFFECT_PRESETS[name];
+    if (!preset) return null;
+
+    const filters = {};
+    for (const [key, value] of Object.entries(preset.filters)) {
+        if (typeof value === 'number') {
+            if (key === 'speed' || key === 'pitch') {
+                // Scale relative to 1.0
+                filters[key] = 1.0 + (value - 1.0) * intensity;
+            } else {
+                filters[key] = value * intensity;
+            }
+        } else if (typeof value === 'boolean') {
+            filters[key] = value;
+        } else if (Array.isArray(value)) {
+            filters[key] = value.map(v => typeof v === 'number' ? v * intensity : v);
+        } else if (typeof value === 'object') {
+            filters[key] = { ...value };
+            for (const [k, v] of Object.entries(filters[key])) {
+                if (typeof v === 'number') {
+                    if (k === 'speed' || k === 'pitch' || k === 'frequency') {
+                         // Some frequency based ones might also need base values but speed/pitch are most critical
+                         filters[key][k] = 1.0 + (v - 1.0) * intensity;
+                    } else {
+                        filters[key][k] = v * intensity;
+                    }
+                }
+            }
+        }
+    }
+    return filters;
+}
+
+module.exports = {
+    buildFfmpegArgs,
+    getAvailableFilters,
+    getPresets,
+    getEQBands,
+    getEffectPresets,
+    getEffectPresetsInfo,
+    applyEffectPreset,
+    PRESETS,
+    EQ_BANDS,
+    EFFECT_PRESETS
+};