streamify-audio 2.1.15 → 2.1.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "streamify-audio",
-  "version": "2.1.15",
+  "version": "2.1.16",
   "description": "Dual-mode audio library: HTTP streaming proxy + Discord player (Lavalink alternative). Supports YouTube, Spotify, SoundCloud with audio filters.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -29,7 +29,8 @@
   "author": "Lucas",
   "license": "MIT",
   "dependencies": {
-    "express": "^4.18.2"
+    "express": "^4.18.2",
+    "opusscript": "^0.0.8"
   },
   "optionalDependencies": {
     "@discordjs/opus": "^0.9.0",

package/src/discord/Manager.js

@@ -217,7 +217,7 @@ class Manager extends EventEmitter {
                     if (!this._isProviderEnabled('youtube')) {
                         throw new Error('YouTube provider is disabled');
                     }
-                    result = await youtube.search(query, limit, this.config);
+                    result = await youtube.search(query, limit, this.config, options);
                     break;
 
                 case 'spotify':

package/src/discord/Player.js

@@ -218,6 +218,10 @@ class Player extends EventEmitter {
         });
 
         this.audioPlayer.on('error', (error) => {
+            if (this._manualSkip || this._changingStream) {
+                return;
+            }
+
             if (error.message === 'Premature close' || error.message.includes('EPIPE')) {
                 return;
             }
@@ -234,7 +238,8 @@ class Player extends EventEmitter {
 
             const next = this.queue.shift();
             if (next) {
-                this._playTrack(next);
+                // Use setImmediate to break recursion stack on consecutive failures
+                setImmediate(() => this._playTrack(next));
             } else {
                 this.emit('queueEnd');
             }
@@ -309,7 +314,7 @@ class Player extends EventEmitter {
             };
 
             if (startPosition === 0 && this._prefetchedTrack?.id === track.id && this._prefetchedStream) {
-                log.info('PLAYER', `Using prefetched stream for ${track.id}`);
+                log.debug('PLAYER', `Using prefetched stream for ${track.id}`);
                 this.stream = this._prefetchedStream;
                 this._prefetchedStream = null;
                 this._prefetchedTrack = null;
@@ -332,10 +337,15 @@ class Player extends EventEmitter {
         } catch (error) {
             log.error('PLAYER', `Failed to play track: ${error.message}`);
             this.emit('trackError', track, error);
+            
+            // If manual skip is active, we just return so the skip function handles it
+            if (this._manualSkip) return;
 
             const next = this.queue.shift();
             if (next) {
-                return this._playTrack(next);
+                // Use setImmediate to break recursion stack on consecutive failures
+                setImmediate(() => this._playTrack(next));
+                return;
             } else {
                 this.emit('queueEnd');
             }
@@ -351,7 +361,7 @@ class Player extends EventEmitter {
         this._prefetching = true;
         this._clearPrefetch();
 
-        log.info('PLAYER', `Prefetching: ${nextTrack.title} (${nextTrack.id})`);
+        log.debug('PLAYER', `Prefetching: ${nextTrack.title} (${nextTrack.id})`);
 
         try {
             const filtersWithVolume = {
@@ -363,7 +373,7 @@ class Player extends EventEmitter {
             this._prefetchedStream = createStream(nextTrack, filtersWithVolume, this.config);
             await this._prefetchedStream.create();
 
-            log.info('PLAYER', `Prefetch ready: ${nextTrack.id}`);
+            log.debug('PLAYER', `Prefetch ready: ${nextTrack.id}`);
         } catch (error) {
             log.debug('PLAYER', `Prefetch failed: ${error.message}`);
             this._clearPrefetch();
@@ -429,7 +439,7 @@ class Player extends EventEmitter {
         }
 
         this.audioPlayer.stop(true);
-        log.info('PLAYER', `Paused at ${Math.floor(this._positionMs / 1000)}s (stream destroyed)`);
+        log.info('PLAYER', `Paused playback at ${Math.floor(this._positionMs / 1000)}s (Reason: User Request)`);
 
         return true;
     }
@@ -438,7 +448,7 @@ class Player extends EventEmitter {
         if (!this._playing || !this._paused) return false;
 
         if (!this.stream && this.queue.current) {
-            log.info('PLAYER', `Resuming from ${Math.floor(this._positionMs / 1000)}s (recreating stream)`);
+            log.info('PLAYER', `Resuming playback from ${Math.floor(this._positionMs / 1000)}s`);
 
             this._changingStream = true;
             const track = this.queue.current;
@@ -488,18 +498,16 @@ class Player extends EventEmitter {
         const next = this.queue.shift();
         this.audioPlayer.stop();
 
-        if (next) {
-            await this._playTrack(next);
-
-            await new Promise(resolve => setTimeout(resolve, 250));
+        log.info('PLAYER', `Skipping track (Next: ${next ? next.title : 'End of queue'})`);
 
-            if (this.queue.current && this.queue.current.id !== next.id) {
-                this._manualSkip = false;
-                return this.queue.current;
+        try {
+            if (next) {
+                await this._playTrack(next);
             }
+        } finally {
+            this._manualSkip = false;
         }
 
-        this._manualSkip = false;
         return this.queue.current || next;
     }
 
@@ -515,16 +523,15 @@ class Player extends EventEmitter {
 
         this._manualSkip = true;
         this.audioPlayer.stop();
-        await this._playTrack(prev);
-
-        await new Promise(resolve => setTimeout(resolve, 250));
+        
+        log.info('PLAYER', `Rewinding to previous track: ${prev.title}`);
 
-        if (this.queue.current && this.queue.current.id !== prev.id) {
+        try {
+            await this._playTrack(prev);
+        } finally {
             this._manualSkip = false;
-            return this.queue.current;
         }
 
-        this._manualSkip = false;
         return this.queue.current || prev;
     }
 
@@ -542,11 +549,16 @@ class Player extends EventEmitter {
         this._positionMs = 0;
         this.queue.clear();
         this.queue.setCurrent(null);
+        
+        log.info('PLAYER', 'Stopped playback and cleared queue');
+        
         return true;
     }
 
     setVolume(volume) {
+        const oldVolume = this._volume;
         this._volume = Math.max(0, Math.min(200, volume));
+        log.info('PLAYER', `Volume adjusted: ${oldVolume}% -> ${this._volume}%`);
         return this._volume;
     }
 
@@ -565,6 +577,8 @@ class Player extends EventEmitter {
             this.stream.destroy();
         }
 
+        log.info('PLAYER', `Seeking to ${Math.floor(positionMs / 1000)}s`);
+
         try {
             this.stream = createStream(track, filtersWithVolume, this.config);
             const resource = await this.stream.create(positionMs);
@@ -580,6 +594,7 @@ class Player extends EventEmitter {
     }
 
     setLoop(mode) {
+        log.info('PLAYER', `Loop mode changed to: ${mode.toUpperCase()}`);
         return this.queue.setRepeatMode(mode);
     }
 
@@ -617,6 +632,7 @@ class Player extends EventEmitter {
 
     async clearFilters() {
         this._filters = {};
+        log.info('PLAYER', 'All audio filters cleared');
         if (this._playing && this.queue.current) {
             return this.setFilter('_trigger', null);
         }
@@ -627,6 +643,7 @@ class Player extends EventEmitter {
         if (!Array.isArray(bands) || bands.length !== 15) {
             throw new Error('EQ must be an array of 15 band gains (-0.25 to 1.0)');
         }
+        log.info('PLAYER', 'Applying custom 15-band Equalizer');
         return this.setFilter('equalizer', bands);
     }
 
@@ -636,12 +653,14 @@ class Player extends EventEmitter {
             throw new Error(`Unknown preset: ${presetName}. Available: ${Object.keys(PRESETS).join(', ')}`);
         }
         delete this._filters.equalizer;
+        log.info('PLAYER', `Applying EQ preset: ${presetName.toUpperCase()}`);
         return this.setFilter('preset', presetName);
     }
 
     async clearEQ() {
         delete this._filters.equalizer;
         delete this._filters.preset;
+        log.info('PLAYER', 'Equalizer cleared');
         if (this._playing && this.queue.current) {
             return this.setFilter('_trigger', null);
         }
@@ -659,7 +678,6 @@ class Player extends EventEmitter {
         }
 
         const replace = options.replace ?? false;
-        const appliedFilters = {};
         const newPresets = [];
 
         for (const preset of presets) {
@@ -670,17 +688,11 @@ class Player extends EventEmitter {
                 log.warn('PLAYER', `Unknown effect preset: ${name}`);
                 continue;
             }
-
-            const filters = applyEffectPreset(name, intensity);
-            if (filters) {
-                Object.assign(appliedFilters, filters);
-                newPresets.push({ name, intensity });
-            }
+            newPresets.push({ name, intensity });
         }
 
         if (replace) {
             this._effectPresets = newPresets;
-            this._filters = appliedFilters;
         } else {
             const existingNames = this._effectPresets.map(p => p.name);
             for (const preset of newPresets) {
@@ -691,9 +703,19 @@ class Player extends EventEmitter {
                     this._effectPresets.push(preset);
                 }
             }
-            this._filters = { ...this._filters, ...appliedFilters };
         }
 
+        // Re-calculate all filters from active presets
+        this._filters = {};
+        for (const preset of this._effectPresets) {
+            const filters = applyEffectPreset(preset.name, preset.intensity);
+            if (filters) {
+                Object.assign(this._filters, filters);
+            }
+        }
+
+        log.info('PLAYER', `Active effects: ${this._effectPresets.map(p => p.name).join(' + ') || 'NONE'}`);
+
         if (this._playing && this.queue.current) {
             return this.setFilter('_trigger', null);
         }
@@ -707,6 +729,7 @@ class Player extends EventEmitter {
     async clearEffectPresets() {
         this._effectPresets = [];
         this._filters = {};
+        log.info('PLAYER', 'All effect presets cleared');
         if (this._playing && this.queue.current) {
             return this.setFilter('_trigger', null);
         }
@@ -779,4 +802,4 @@ class Player extends EventEmitter {
     }
 }
 
-module.exports = Player;
+module.exports = Player;

package/src/discord/Stream.js

@@ -22,6 +22,17 @@ class StreamController {
         this.destroyed = false;
         this.startTime = null;
         this.bytesReceived = 0;
+        this.bytesSent = 0;
+        this.ytdlpError = '';
+        this.ffmpegError = '';
+        
+        // Timing metrics
+        this.metrics = {
+            metadata: 0,
+            spawn: 0,
+            firstByte: 0,
+            total: 0
+        };
     }
 
     async create(seekPosition = 0) {
@@ -34,6 +45,7 @@ class StreamController {
         }
 
         this.startTime = Date.now();
+        const startTimestamp = this.startTime;
         const source = this.track.source || 'youtube';
 
         let videoId = this.track._resolvedId || this.track.id;
@@ -44,10 +56,13 @@ class StreamController {
                 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 = Date.now() - startTimestamp;
         }
 
         if (!videoId || videoId === 'undefined') {
@@ -55,6 +70,17 @@ class StreamController {
         }
 
         log.info('STREAM', `Creating stream for ${videoId} (${source})`);
+        
+        // Log Filter Chain
+        const filterNames = Object.keys(this.filters).filter(k => k !== 'start' && k !== '_trigger');
+        if (filterNames.length > 0) {
+            const chain = filterNames.map(name => {
+                const val = this.filters[name];
+                const displayVal = typeof val === 'object' ? JSON.stringify(val) : val;
+                return `[${name} (${displayVal})]`;
+            }).join(' -> ');
+            log.debug('STREAM', `Filter Chain: ${chain}`);
+        }
 
         let url;
         if (source === 'soundcloud') {
@@ -106,35 +132,45 @@ class StreamController {
             ytdlpArgs.push('--sponsorblock-remove', categories.join(','));
         }
 
-        this.ytdlp = spawn(this.config.ytdlpPath, ytdlpArgs, {
-            env: { ...process.env, PATH: '/usr/local/bin:/root/.deno/bin:' + process.env.PATH }
-        });
+        const env = { ...process.env, PATH: '/usr/local/bin:/root/.deno/bin:' + process.env.PATH };
 
-        this._spawnTime = Date.now() - this.startTime;
+        const spawnStart = Date.now();
+        this.ytdlp = spawn(this.config.ytdlpPath, ytdlpArgs, { env });
 
         const ffmpegFilters = { ...this.filters };
-        if (seekPosition > 0) {
-            ffmpegFilters.start = seekPosition / 1000;
-        }
-
         const ffmpegArgs = buildFfmpegArgs(ffmpegFilters, this.config);
-        this.ffmpeg = spawn(this.config.ffmpegPath, ffmpegArgs);
+        this.ffmpeg = spawn(this.config.ffmpegPath, ffmpegArgs, { env });
+        
+        this.metrics.spawn = Date.now() - spawnStart;
+
+        const { pipeline } = require('stream');
 
         this._firstDataTime = null;
+        
         this.ytdlp.stdout.on('data', (chunk) => {
+            this.bytesReceived += chunk.length;
+        });
+
+        this.ffmpeg.stdout.on('data', (chunk) => {
             if (!this._firstDataTime) {
                 this._firstDataTime = Date.now() - this.startTime;
+                this.metrics.firstByte = Date.now() - (startTimestamp + this.metrics.metadata + this.metrics.spawn);
             }
-            this.bytesReceived += chunk.length;
+            this.bytesSent += chunk.length;
         });
 
-        this.ytdlp.stdout.pipe(this.ffmpeg.stdin);
+        pipeline(this.ytdlp.stdout, this.ffmpeg.stdin, (err) => {
+            if (err && !this.destroyed) {
+                if (err.code !== 'ERR_STREAM_PREMATURE_CLOSE' && err.code !== 'EPIPE') {
+                    log.debug('STREAM', `Pipeline error: ${err.message}`);
+                }
+            }
+        });
 
-        let ytdlpError = '';
         this.ytdlp.stderr.on('data', (data) => {
             if (this.destroyed) return;
             const msg = data.toString();
-            ytdlpError += msg;
+            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')) {
@@ -145,6 +181,7 @@ class StreamController {
         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());
             }
@@ -153,11 +190,11 @@ class StreamController {
         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.ytdlpError) {
+                    log.error('STREAM', `yt-dlp stderr: ${this.ytdlpError.slice(-500)}`);
                 }
             }
-            if (this.ffmpeg && !this.ffmpeg.killed) {
+            if (this.ffmpeg && !this.ffmpeg.killed && this.ffmpeg.stdin) {
                 this.ffmpeg.stdin.end();
             }
         });
@@ -199,9 +236,10 @@ class StreamController {
             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] | Buffered: ${this.bytesSent}b`);
 
         return this.resource;
     }
@@ -210,7 +248,7 @@ class StreamController {
         return new Promise((resolve, reject) => {
             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 (received: ${this.bytesSent}, isLive: ${isLive})`);
                 resolve();
             }, timeoutMs);
 
@@ -221,7 +259,7 @@ class StreamController {
                     clearInterval(checkInterval);
                     return;
                 }
-                if (this.bytesReceived > 0) {
+                if (this.bytesSent > 0) {
                     resolved = true;
                     clearTimeout(timeout);
                     clearInterval(checkInterval);
@@ -234,7 +272,7 @@ class StreamController {
                     resolved = true;
                     clearTimeout(timeout);
                     clearInterval(checkInterval);
-                    reject(new Error('ffmpeg closed before producing data'));
+                    reject(new Error(`ffmpeg closed before producing data. ffmpeg stderr: ${this.ffmpegError.slice(-200) || 'none'} | yt-dlp stderr: ${this.ytdlpError.slice(-200) || 'none'}`));
                 }
             });
 
@@ -243,7 +281,7 @@ class StreamController {
                     resolved = true;
                     clearTimeout(timeout);
                     clearInterval(checkInterval);
-                    reject(new Error(`yt-dlp failed with code ${code}`));
+                    reject(new Error(`yt-dlp failed with code ${code}. stderr: ${this.ytdlpError.slice(-200) || 'none'}`));
                 }
             });
         });
@@ -254,7 +292,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: ${elapsed}ms | Data Out: ${(this.bytesSent / 1024 / 1024).toFixed(2)} MB`);
 
         try {
             if (this.ytdlp && this.ffmpeg) {
@@ -287,4 +325,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,27 +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: 10 }, description: 'Boost bass frequencies' },
+    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.2 } }, description: '8D rotating audio effect' },
+    '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.9 }, description: 'Deep bass with lower pitch' },
-    lofi: { filters: { lowpass: 3000, bass: 5 }, description: 'Lo-fi aesthetic' },
-    radio: { filters: { highpass: 300, lowpass: 5000 }, description: 'Radio/telephone effect' },
-    telephone: { filters: { highpass: 500, lowpass: 3500 }, description: 'Old telephone effect' },
-    soft: { filters: { bass: -5, treble: -3, volume: 70 }, description: 'Softer, quieter sound' },
-    loud: { filters: { bass: 5, treble: 3, compressor: true }, description: 'Louder, compressed sound' },
-    chipmunk: { filters: { pitch: 1.5 }, description: 'High-pitched chipmunk voice' },
-    darth: { filters: { pitch: 0.7 }, description: 'Deep Darth Vader voice' },
+    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: 5, depth: 0.5 } }, description: 'Vibrato effect' },
-    tremolo: { filters: { tremolo: { frequency: 5, depth: 0.5 } }, description: 'Tremolo 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) {
@@ -84,11 +95,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);
@@ -205,18 +212,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) {
@@ -275,6 +288,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' }
     };
 }
@@ -306,14 +321,24 @@ function applyEffectPreset(name, intensity = 1.0) {
     const filters = {};
     for (const [key, value] of Object.entries(preset.filters)) {
         if (typeof value === 'number') {
-            filters[key] = value * intensity;
+            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 (typeof value === 'object') {
             filters[key] = { ...value };
             for (const [k, v] of Object.entries(filters[key])) {
                 if (typeof v === 'number') {
-                    filters[key][k] = v * intensity;
+                    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;
+                    }
                 }
             }
         }
@@ -332,4 +357,4 @@ module.exports = {
     PRESETS,
     EQ_BANDS,
     EFFECT_PRESETS
-};
+};

package/src/providers/youtube.js

@@ -3,23 +3,42 @@ const { buildFfmpegArgs } = require('../filters/ffmpeg');
 const { registerStream, unregisterStream } = require('../utils/stream');
 const log = require('../utils/logger');
 
-async function search(query, limit, config) {
+async function search(query, limit, config, options = {}) {
     const startTime = Date.now();
-    log.info('YOUTUBE', `Searching: "${query}" (limit: ${limit})`);
+    log.info('YOUTUBE', `Searching: "${query}" (limit: ${limit}, type: ${options.type || 'all'}, sort: ${options.sort || 'relevance'})`);
 
     return new Promise((resolve, reject) => {
         const args = [
             '-q', '--no-warnings',
             '--flat-playlist',
             '--skip-download',
-            '-J',
-            `ytsearch${limit}:${query}`
+            '-J'
         ];
 
         if (config.cookiesPath) {
             args.unshift('--cookies', config.cookiesPath);
         }
 
+        let searchQuery = query;
+        
+        // Handle sorting by modifying search query or using filters
+        if (options.sort === 'views' || options.sort === 'popular') {
+            searchQuery += ' most viewed';
+        } else if (options.sort === 'date' || options.sort === 'latest') {
+            searchQuery += ' new';
+        }
+
+        // Handle type filtering
+        if (options.type === 'live') {
+            args.push('--match-filter', 'live_status = is_live');
+        } else if (options.type === 'playlist') {
+            args.push('--match-filter', 'playlist_count > 0');
+        } else if (options.type === 'video') {
+            args.push('--match-filter', 'live_status != is_live');
+        }
+
+        args.push(`ytsearch${limit}:${searchQuery}`);
+
         const proc = spawn(config.ytdlpPath, args, {
             env: { ...process.env, PATH: '/usr/local/bin:/root/.deno/bin:' + process.env.PATH }
         });

package/src/server.js

@@ -93,14 +93,14 @@ class Server {
                 if (!this._isProviderEnabled('youtube')) {
                     return res.status(400).json({ error: 'YouTube provider is disabled' });
                 }
-                const { q, limit = 10 } = req.query;
+                const { q, limit = 10, type, sort } = req.query;
                 if (!q) return res.status(400).json({ error: 'Missing query parameter: q' });
 
-                const cacheKey = `yt:search:${q}:${limit}`;
+                const cacheKey = `yt:search:${q}:${limit}:${type}:${sort}`;
                 const cached = cache.get(cacheKey);
                 if (cached) return res.json(cached);
 
-                const results = await youtube.search(q, parseInt(limit), this.config);
+                const results = await youtube.search(q, parseInt(limit), this.config, { type, sort });
                 cache.set(cacheKey, results, this.config.cache.searchTTL);
                 res.json(results);
             } catch (error) {
@@ -228,7 +228,7 @@ class Server {
 
         this.app.get('/search', async (req, res) => {
             try {
-                const { q, source = 'youtube', limit = 10 } = req.query;
+                const { q, source = 'youtube', limit = 10, type, sort } = req.query;
                 if (!q) return res.status(400).json({ error: 'Missing query parameter: q' });
 
                 let results;
@@ -252,7 +252,7 @@ class Server {
                         if (!this._isProviderEnabled('youtube')) {
                             return res.status(400).json({ error: 'YouTube provider is disabled' });
                         }
-                        results = await youtube.search(q, parseInt(limit), this.config);
+                        results = await youtube.search(q, parseInt(limit), this.config, { type, sort });
                 }
                 res.json(results);
             } catch (error) {

package/src/utils/logger.js

@@ -52,45 +52,67 @@ function formatTime() {
 }
 
 function formatTag(tag, color) {
-    return colorize(color, `[${tag}]`);
+    return colorize(color, `[${tag.toUpperCase()}]`);
 }
 
 function debug(tag, ...args) {
     if (currentLevel < LOG_LEVELS.debug) return;
-    console.log(formatTime(), formatTag(tag, 'gray'), colorize('dim', args.join(' ')));
+    console.log(formatTime(), '🐛', formatTag(tag, 'gray'), colorize('dim', args.join(' ')));
 }
 
 function info(tag, ...args) {
     if (currentLevel < LOG_LEVELS.info) return;
-    console.log(formatTime(), formatTag(tag, 'cyan'), ...args);
+    const tagUpper = tag.toUpperCase();
+    const color = {
+        'MANAGER': 'cyan',
+        'PLAYER': 'blue',
+        'YOUTUBE': 'red',
+        'SPOTIFY': 'green',
+        'SOUNDCLOUD': 'yellow',
+        'STREAM': 'cyan'
+    }[tagUpper] || 'cyan';
+    
+    const emojiMap = {
+        'MANAGER': 'ℹ️ ',
+        'YOUTUBE': '🔴 ',
+        'SPOTIFY': '🟢 ',
+        'SOUNDCLOUD': '🟠 ',
+        'PLAYER': '🔹 ',
+        'STREAM': '🎵 '
+    };
+    
+    const emoji = emojiMap[tagUpper] || '   ';
+    console.log(formatTime(), emoji, formatTag(tag, color), ...args);
 }
 
 function success(tag, ...args) {
     if (currentLevel < LOG_LEVELS.info) return;
-    console.log(formatTime(), formatTag(tag, 'green'), colorize('green', args.join(' ')));
+    console.log(formatTime(), '✅ ', formatTag(tag, 'green'), colorize('green', args.join(' ')));
 }
 
 function warn(tag, ...args) {
     if (currentLevel < LOG_LEVELS.warn) return;
-    console.warn(formatTime(), formatTag(tag, 'yellow'), colorize('yellow', args.join(' ')));
+    console.warn(formatTime(), '⚠️  ', formatTag(tag, 'yellow'), colorize('yellow', args.join(' ')));
 }
 
 function error(tag, ...args) {
     if (currentLevel < LOG_LEVELS.error) return;
-    console.error(formatTime(), formatTag(tag, 'red'), colorize('red', args.join(' ')));
+    console.error(formatTime(), '❌ ', formatTag(tag, 'red'), colorize('red', args.join(' ')));
 }
 
 function stream(source, id, message) {
     if (currentLevel < LOG_LEVELS.debug) return;
-    const sourceColor = {
-        youtube: 'red',
-        spotify: 'green',
-        soundcloud: 'yellow'
-    }[source] || 'white';
+    const sourceMap = {
+        youtube: { color: 'red', emoji: '🔴 ' },
+        spotify: { color: 'green', emoji: '🟢 ' },
+        soundcloud: { color: 'yellow', emoji: '🟠 ' }
+    };
+    const { color, emoji } = sourceMap[source.toLowerCase()] || { color: 'white', emoji: '🎵 ' };
 
     console.log(
         formatTime(),
-        formatTag('STREAM', sourceColor),
+        emoji,
+        colorize('cyan', '[STREAM]'),
         colorize('dim', `[${id}]`),
         message
     );