streamify-audio 2.2.13 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "streamify-audio",
-  "version": "2.2.13",
+  "version": "2.3.0",
   "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",

package/src/config.js

@@ -26,8 +26,8 @@ const defaults = {
         bitrate: '128k',
         format: 'opus',
         vbr: true,
-        compressionLevel: 10,
-        application: 'audio'
+        compressionLevel: 5,
+        application: 'lowdelay'
     },
     ytdlp: {
         format: 'bestaudio/bestaudio[ext=webm]/bestaudio[ext=mp4]/18/22/best',
@@ -38,6 +38,13 @@ const defaults = {
         searchTTL: 300,
         infoTTL: 3600,
         redis: null
+    },
+    stream: {
+        dataTimeout: 8000,
+        liveDataTimeout: 15000,
+        urlCacheTTL: 1800,
+        bufferSize: '1M',
+        maxRetries: 2
     }
 };
 
@@ -107,6 +114,11 @@ function load(options = {}) {
             ...defaults.cache,
             ...fileConfig.cache,
             ...options.cache
+        },
+        stream: {
+            ...defaults.stream,
+            ...fileConfig.stream,
+            ...options.stream
         }
     };
 

package/src/discord/Player.js

@@ -48,6 +48,7 @@ class Player extends EventEmitter {
         this._prefetching = false;
         this._changingStream = false;
         this._manualSkip = false;
+        this._pauseStreamTimeout = null;
 
         this.autoLeave = {
             enabled: options.autoLeave?.enabled ?? true,
@@ -316,22 +317,23 @@ class Player extends EventEmitter {
         this.emit('trackStart', track);
 
         let newStream = null;
+        let resource = null;
+
         try {
             const filtersWithVolume = { ...this._filters, volume: this._volume };
 
-            if (startPosition === 0 && this._prefetchedTrack?.id === track.id && this._prefetchedStream) {
-                log.debug('PLAYER', `Using prefetched stream for ${track.id}`);
+            if (startPosition === 0 && this._prefetchedTrack?.id === track.id && this._prefetchedStream?.resource) {
+                log.info('PLAYER', `Using prefetched stream for ${track.id}`);
                 newStream = this._prefetchedStream;
+                resource = newStream.resource;
                 this._prefetchedStream = null;
                 this._prefetchedTrack = null;
             } else {
-                // If not using prefetch, we don't clear it yet in case we need to fallback
+                this._clearPrefetch();
                 newStream = createStream(track, filtersWithVolume, this.config);
+                resource = await newStream.start(startPosition);
             }
 
-            const resource = await newStream.create(startPosition);
-
-            // SEAMLESS SWAP: Only destroy old stream AFTER the new one is ready
             const oldStream = this.stream;
             this.stream = newStream;
             this.audioPlayer.play(resource);
@@ -361,7 +363,7 @@ class Player extends EventEmitter {
 
             log.error('PLAYER', `Failed to play track: ${error.message}`);
             this.emit('trackError', track, error);
-            
+
             const next = this.queue.shift();
             if (next) {
                 setImmediate(() => this._playTrack(next));
@@ -383,19 +385,35 @@ class Player extends EventEmitter {
         if (this._prefetching || this.queue.tracks.length === 0) return;
 
         const nextTrack = this.queue.tracks[0];
-        if (!nextTrack || nextTrack._directUrl) return; // Already prefetched or resolved
+        if (!nextTrack) return;
+
+        if (this._prefetchedTrack?.id === nextTrack.id && this._prefetchedStream) return;
 
+        this._clearPrefetch();
         this._prefetching = true;
-        log.debug('PLAYER', `Prefetching metadata: ${nextTrack.title}`);
+        log.debug('PLAYER', `Prefetching stream: ${nextTrack.title}`);
 
         try {
-            // Only resolve the metadata and stream URL
-            const result = await this.manager.getInfo(nextTrack.id, nextTrack.source);
-            if (result) {
-                // Merge prefetch data into the existing queue object
-                Object.assign(nextTrack, result);
-                log.debug('PLAYER', `Prefetch ready (Metadata only): ${nextTrack.id}`);
+            const filtersWithVolume = { ...this._filters, volume: this._volume };
+            const stream = createStream(nextTrack, filtersWithVolume, this.config);
+
+            await stream.prepare();
+
+            if (this._destroyed || this.queue.tracks[0]?.id !== nextTrack.id) {
+                stream.destroy();
+                return;
+            }
+
+            await stream.start(0);
+
+            if (this._destroyed || this.queue.tracks[0]?.id !== nextTrack.id) {
+                stream.destroy();
+                return;
             }
+
+            this._prefetchedStream = stream;
+            this._prefetchedTrack = nextTrack;
+            log.info('PLAYER', `Prefetch ready: ${nextTrack.title} (${stream.metrics.total}ms)`);
         } catch (error) {
             log.debug('PLAYER', `Prefetch failed: ${error.message}`);
         } finally {
@@ -492,7 +510,7 @@ class Player extends EventEmitter {
         }
     }
 
-    pause(destroyStream = true) {
+    pause(destroyStream = false) {
         if (!this._playing || this._paused) return false;
 
         this._positionMs = this.position;
@@ -502,10 +520,23 @@ class Player extends EventEmitter {
             this._clearPrefetch();
             this.stream.destroy();
             this.stream = null;
+            this.audioPlayer.stop(true);
+        } else {
+            this.audioPlayer.pause();
         }
 
-        this.audioPlayer.stop(true);
-        log.info('PLAYER', `Paused playback at ${Math.floor(this._positionMs / 1000)}s (Reason: User Request)`);
+        if (!destroyStream && this.stream) {
+            this._pauseStreamTimeout = setTimeout(() => {
+                if (this._paused && this.stream) {
+                    log.info('PLAYER', 'Destroying paused stream after 5m idle');
+                    this._clearPrefetch();
+                    this.stream.destroy();
+                    this.stream = null;
+                }
+            }, 300000);
+        }
+
+        log.info('PLAYER', `Paused playback at ${Math.floor(this._positionMs / 1000)}s (stream kept: ${!destroyStream})`);
         this._clearVoiceChannelStatus();
 
         return true;
@@ -514,8 +545,13 @@ class Player extends EventEmitter {
     async resume() {
         if (!this._playing || !this._paused) return false;
 
+        if (this._pauseStreamTimeout) {
+            clearTimeout(this._pauseStreamTimeout);
+            this._pauseStreamTimeout = null;
+        }
+
         if (!this.stream && this.queue.current) {
-            log.info('PLAYER', `Resuming playback from ${Math.floor(this._positionMs / 1000)}s`);
+            log.info('PLAYER', `Resuming playback from ${Math.floor(this._positionMs / 1000)}s (recreating stream)`);
 
             this._changingStream = true;
             const track = this.queue.current;
@@ -547,6 +583,7 @@ class Player extends EventEmitter {
             this.audioPlayer.unpause();
             this._paused = false;
             this._positionTimestamp = Date.now();
+            log.info('PLAYER', `Resumed playback instantly at ${Math.floor(this._positionMs / 1000)}s`);
             this._updateVoiceChannelStatus(this.queue.current, true);
         }
 
@@ -630,10 +667,21 @@ class Player extends EventEmitter {
         return true;
     }
 
-    setVolume(volume) {
+    async setVolume(volume) {
+        this._clearPrefetch();
         const oldVolume = this._volume;
         this._volume = Math.max(0, Math.min(200, volume));
         log.info('PLAYER', `Volume adjusted: ${oldVolume}% -> ${this._volume}%`);
+
+        if (this._playing && this.queue.current && !this._paused) {
+            this._changingStream = true;
+            try {
+                await this._playTrack(this.queue.current, this.position);
+            } finally {
+                this._changingStream = false;
+            }
+        }
+
         return this._volume;
     }
 
@@ -659,6 +707,7 @@ class Player extends EventEmitter {
     }
 
     async setFilter(name, value) {
+        this._clearPrefetch();
         this._filters[name] = value;
 
         if (this._playing && this.queue.current) {
@@ -757,6 +806,7 @@ class Player extends EventEmitter {
             }
         }
 
+        this._clearPrefetch();
         log.info('PLAYER', `Active effects: ${this._effectPresets.map(p => p.name).join(' + ') || 'NONE'}`);
 
         if (this._playing && this.queue.current) {
@@ -801,6 +851,10 @@ class Player extends EventEmitter {
             clearTimeout(this._inactivityTimeout);
             this._inactivityTimeout = null;
         }
+        if (this._pauseStreamTimeout) {
+            clearTimeout(this._pauseStreamTimeout);
+            this._pauseStreamTimeout = null;
+        }
 
         this._clearPrefetch();