ziplayer 0.3.7 → 0.3.8

package/dist/structures/Player.js

@@ -193,7 +193,7 @@ class Player extends events_1.EventEmitter {
             extractorTimeout: this.options.extractorTimeout,
         });
         this.streamManager = new StreamManager_1.StreamManager({
-            maxConcurrentStreams: 2,
+            maxConcurrentStreams: 4,
             streamTimeout: 5 * 60 * 1000,
             maxListenersPerStream: 15,
             enableMetrics: true,
@@ -751,25 +751,26 @@ class Player extends events_1.EventEmitter {
     async createResource(streamInfo, track, position = 0) {
         const filterString = this.filter.getFilterString();
         this.debug(`[Player] Creating AudioResource — filters: ${filterString || "none"}, seek: ${position}ms`);
-        // -1 = sentinel "no seek requested"
+        this.filter.setSourceStreamType(streamInfo.type);
         const seekArg = position > 0 ? position : -1;
         if (filterString || position > 0) {
-            // throws on failure — do NOT fall back to the already-piped stream
             const processedStream = await this.filter.applyFiltersAndSeek(streamInfo.stream, seekArg);
-            streamInfo.type = voice_1.StreamType.Arbitrary;
-            return (0, voice_1.createAudioResource)(processedStream, {
+            // rawStream. Always use Arbitrary so discordjs/voice doesn't re-encode.
+            const resource = (0, voice_1.createAudioResource)(processedStream, {
                 metadata: track,
                 inputType: voice_1.StreamType.Arbitrary,
                 inlineVolume: true,
             });
+            return { resource, processedStream };
         }
-        return (0, voice_1.createAudioResource)(streamInfo.stream, {
+        const resource = (0, voice_1.createAudioResource)(streamInfo.stream, {
             metadata: track,
             inputType: streamInfo.type === "webm/opus" ? voice_1.StreamType.WebmOpus
                 : streamInfo.type === "ogg/opus" ? voice_1.StreamType.OggOpus
                     : voice_1.StreamType.Arbitrary,
             inlineVolume: true,
         });
+        return { resource, processedStream: null };
     }
     mergeTrackPreserveRef(target, source) {
         if (source === target)
@@ -870,7 +871,14 @@ class Player extends events_1.EventEmitter {
     async startTrack(track) {
         if (this.destroyed)
             return false;
-        // First, get stream info (this will handle remote detection)
+        // Check preload BEFORE calling getStream so we never fetch a
+        // stream we're about to throw away. The original code called getStream()
+        // unconditionally at the top, then used the preload if available — leaking
+        // the just-fetched stream and running middleware twice.
+        if (this.preloadManager.hasValidPreload(track)) {
+            return await this.startFromPreload(track);
+        }
+        // Only fetch a stream when there is no usable preload.
         let streamInfo = null;
         try {
             streamInfo = await this.getStream(track);
@@ -879,101 +887,103 @@ class Player extends events_1.EventEmitter {
             this.debug(`[Player] Failed to get stream for track: ${track.title}`, error);
             throw error;
         }
-        // Handle remote playback
+        // Remote playback
         if (streamInfo?.remote && streamInfo.handle) {
             return await this.playRemote(track, streamInfo);
         }
-        // Handle native playback
+        // Native playback — pass the already-fetched streamInfo to avoid a second fetch
+        return await this.loadFreshStream(track, streamInfo);
+    }
+    async startFromPreload(track) {
+        if (this.destroyed)
+            return false;
+        this.debug(`[Player] Using preloaded stream for: ${track.title}`);
+        const oldStreamId = this.currentSlot.streamId;
+        this.promotePreloadToCurrent(track);
+        if (oldStreamId && oldStreamId !== this.currentSlot.streamId) {
+            this.streamManager.unregisterStream(oldStreamId, true);
+            this.debug(`[Player] Released old stream ${oldStreamId} after preload promotion`);
+        }
+        const currentResource = this.currentSlot.resource;
+        if (!currentResource)
+            return false;
+        this.seekOffset = 0;
+        const targetVolume = this.getTrackTargetVolume(track);
+        if (currentResource.volume) {
+            currentResource.volume.setVolume(this.crossfadeEnabled ? 0 : targetVolume);
+        }
+        await this.maybeAlignToBeatBoundary();
+        this.refreshLock = true;
         try {
-            // Try to use preloaded resource
-            if (this.preloadManager.hasValidPreload(track)) {
-                this.debug(`[Player] Using preloaded stream for: ${track.title}`);
-                const oldStreamId = this.currentSlot.streamId;
-                if (oldStreamId && this.streamManager) {
-                    setTimeout(() => {
-                        if (this.currentSlot.streamId === oldStreamId) {
-                            this.streamManager.unregisterStream(oldStreamId, true);
-                        }
-                    }, 3000);
-                }
-                this.promotePreloadToCurrent(track);
-                const currentResource = this.currentSlot.resource;
-                if (!currentResource) {
-                    return false;
-                }
-                this.seekOffset = 0;
-                const targetVolume = this.getTrackTargetVolume(track);
-                if (currentResource.volume) {
-                    currentResource.volume.setVolume(this.crossfadeEnabled ? 0 : targetVolume);
-                }
-                await this.maybeAlignToBeatBoundary();
-                this.refreshLock = true;
-                try {
-                    this.audioPlayer.stop(true);
-                    this.audioPlayer.play(currentResource);
-                    await (0, voice_1.entersState)(this.audioPlayer, voice_1.AudioPlayerStatus.Playing, 10_000);
-                }
-                finally {
-                    this.refreshLock = false;
-                }
-                await this.applyCrossfadeIn(currentResource, track);
-                this.preloadNextTrack().catch((err) => {
-                    this.debug(`[Player] Preload error:`, err);
-                });
-                return true;
-            }
-            this.debug(`[Player] No preload available, loading fresh: ${track.title}`);
-            return await this.loadFreshStream(track);
+            this.audioPlayer.stop(true);
+            this.audioPlayer.play(currentResource);
+            await (0, voice_1.entersState)(this.audioPlayer, voice_1.AudioPlayerStatus.Playing, 10_000);
         }
-        catch (error) {
-            this.debug(`[Player] startTrack error:`, error);
-            this.emit("playerError", error, track);
-            return false;
+        finally {
+            this.refreshLock = false;
         }
+        await this.applyCrossfadeIn(currentResource, track);
+        this.preloadNextTrack().catch((err) => {
+            this.debug(`[Player] Preload error:`, err);
+        });
+        return true;
     }
     /**
      * Load fresh stream when no preload available
      */
-    async loadFreshStream(track) {
+    async loadFreshStream(track, preloadedStreamInfo) {
         if (this.destroyed)
             return false;
-        // Cancel preload to free resources
         await this.safeCancelPreload();
         try {
-            const streamInfo = await this.getStream(track);
-            // Handle remote playback
+            // use caller-supplied streamInfo when available so we don't
+            // call getStream() a second time and run middleware twice.
+            const streamInfo = preloadedStreamInfo ?? (await this.getStream(track));
             if (streamInfo?.remote && streamInfo.handle) {
                 return await this.playRemote(track, streamInfo);
             }
             if (!streamInfo?.stream) {
                 throw new Error(`No stream available`);
             }
-            // Register with StreamManager
-            const streamId = this.streamManager.registerStream(streamInfo.stream, track, {
+            // Register the RAW source stream — this is what we can reuse on seek
+            const rawStreamId = this.streamManager.registerStream(streamInfo.stream, track, {
                 source: track.source || "stream",
                 isPreload: false,
                 isRemote: !!streamInfo?.remote,
                 priority: 10,
             });
-            // Create resource
-            const resource = await this.createResource(streamInfo, track, 0);
-            // Clean up old current
-            if (this.currentSlot.streamId && this.currentSlot.streamId !== streamId) {
+            // createResource now returns both the AudioResource
+            // AND the processedStream (ffmpeg stdout) when filters/seek are involved.
+            const { resource, processedStream } = await this.createResource(streamInfo, track, 0);
+            // when a processedStream exists, register it too so its
+            // lifecycle is tracked. Store its id separately in currentSlot so
+            // destroyCurrentStream() and refreshPlayerResource() clean the right object.
+            let playStreamId = rawStreamId;
+            if (processedStream && processedStream !== streamInfo.stream) {
+                playStreamId = this.streamManager.registerStream(processedStream, track, {
+                    source: track.source || "stream-processed",
+                    isPreload: false,
+                    priority: 10,
+                });
+                this.debug(`[Player] Registered processedStream ${playStreamId} (rawStream: ${rawStreamId})`);
+            }
+            if (this.currentSlot.streamId && this.currentSlot.streamId !== rawStreamId) {
                 this.streamManager.unregisterStream(this.currentSlot.streamId, true);
             }
-            // Set current slot
+            if (this.currentSlot.processedStreamId && this.currentSlot.processedStreamId !== playStreamId) {
+                this.streamManager.unregisterStream(this.currentSlot.processedStreamId, true);
+            }
             this.currentSlot.resource = resource;
             this.currentSlot.track = track;
-            this.currentSlot.streamId = streamId;
+            this.currentSlot.streamId = rawStreamId;
+            this.currentSlot.processedStreamId = processedStream ? playStreamId : null;
             this.currentSlot.isValid = true;
             this.currentResource = resource;
-            this.seekOffset = 0; // new track — reset seek baseline
-            // Apply volume
+            this.seekOffset = 0;
             const targetVolume = this.getTrackTargetVolume(track);
             if (resource.volume) {
                 resource.volume.setVolume(this.crossfadeEnabled ? 0 : targetVolume);
             }
-            // Play — lock refresh so Idle event doesn't spawn duplicate playNext
             await this.maybeAlignToBeatBoundary();
             this.refreshLock = true;
             try {
@@ -985,7 +995,6 @@ class Player extends events_1.EventEmitter {
                 this.refreshLock = false;
             }
             await this.applyCrossfadeIn(resource, track);
-            // Preload next (async)
             if (!this.destroyed) {
                 this.preloadNextTrack().catch((err) => {
                     this.debug(`[Player] Preload error:`, err);
@@ -1153,7 +1162,7 @@ class Player extends events_1.EventEmitter {
                 throw new Error(`No stream available for track: ${track.title}`);
             }
             ttsStream = streamInfo.stream;
-            const resource = await this.createResource(streamInfo, track);
+            const { resource, processedStream } = await this.createResource(streamInfo, track);
             if (!resource) {
                 throw new Error(`No resource available for track: ${track.title}`);
             }
@@ -2134,10 +2143,7 @@ class Player extends events_1.EventEmitter {
             this.debug(`[Player] refreshPlayerResource skipped — lock held`);
             return false;
         }
-        // Lock before anything so stateChange idle sees it when stop() fires.
         this.refreshLock = true;
-        // Clear any existing stuckTimer from the previous playback cycle so it
-        // cannot fire while we are mid-refresh.
         if (this.stuckTimer) {
             clearTimeout(this.stuckTimer);
             this.stuckTimer = null;
@@ -2149,11 +2155,9 @@ class Player extends events_1.EventEmitter {
             this.seekOffset = currentPosition;
             const wasPaused = this.isPaused;
             const playbackDuration = this.currentResource?.playbackDuration ?? 0;
-            // Reuse is only viable for forward seeks (stream is sequential).
             const isForwardSeek = position < 0 || position >= playbackDuration;
             const currentStreamId = this.currentSlot.streamId;
-            // Try to grab the live source stream for reuse.
-            // getRawStream accepts "paused" streams (discordjs/voice pauses source streams on NoSubscriberBehavior); getStream would reject them.
+            // Try to grab the raw source stream for reuse (forward seeks only)
             let reuseStream = null;
             if (isForwardSeek && currentStreamId) {
                 reuseStream = this.streamManager.getRawStream(currentStreamId);
@@ -2161,27 +2165,24 @@ class Player extends events_1.EventEmitter {
                     this.debug(`[Player] Will reuse source stream for seek (pos: ${currentPosition}ms)`);
                 }
             }
-            // ── CRITICAL: unpipe BEFORE stop ──────────────────────────────────────
-            // stop() kills discordjs/voice internal FFmpeg → EPIPE on source stream.
-            // unpipe() first disconnects our stream cleanly before that happens.
             if (reuseStream) {
                 reuseStream.unpipe();
             }
-            // Remove StreamManager listeners.
-            // forceDestroy=false when reusing so the Readable object stays alive.
+            // Clean up processedStream first (it's what AudioResource reads)
+            const processedStreamId = this.currentSlot.processedStreamId;
+            if (processedStreamId && processedStreamId !== currentStreamId) {
+                this.streamManager.unregisterStream(processedStreamId, true);
+                this.currentSlot.processedStreamId = null;
+            }
             if (currentStreamId) {
                 this.streamManager.unregisterStream(currentStreamId, !reuseStream);
                 this.currentSlot.streamId = null;
             }
-            // Stop the AudioPlayer.
-            // stateChange (playing→idle) fires; refreshLock=true guards it (v4 fix).
             this.audioPlayer.stop(true);
             this.currentResource = null;
             this.currentSlot.resource = null;
             this.currentSlot.isValid = false;
-            // One event-loop tick: lets deferred stream events settle.
             await new Promise((resolve) => setImmediate(resolve));
-            // Verify the reuse stream survived stop().
             if (reuseStream) {
                 if (reuseStream.destroyed || reuseStream.readable === false) {
                     this.debug(`[Player] Source stream did not survive stop — falling back to fresh stream`);
@@ -2193,7 +2194,6 @@ class Player extends events_1.EventEmitter {
                 streaminfo = { stream: reuseStream, type: "arbitrary" };
             }
             else {
-                // Clear caches so we don't get the dead Readable back.
                 this.pluginManager.clearStreamCache();
                 this.extensionManager.clearCache("stream");
                 this.debug(`[Player] Fetching fresh stream${!isForwardSeek ? " (backward seek)" : " (reuse failed)"}`);
@@ -2203,20 +2203,28 @@ class Player extends events_1.EventEmitter {
                 this.debug(`[Player] No stream available for refresh`);
                 return false;
             }
-            // Build AudioResource (input-side FFmpeg seek via FilterManager).
-            const resource = await this.createResource(streaminfo, track, currentPosition);
-            // Register the source stream.
+            const createPosition = reuseStream ? -1 : currentPosition;
+            const { resource, processedStream } = await this.createResource(streaminfo, track, createPosition);
+            // Register raw source stream
             const newStreamId = this.streamManager.registerStream(streaminfo.stream, track, {
                 source: track.source || "stream",
                 isPreload: false,
                 priority: 10,
             });
+            let newProcessedStreamId = null;
+            if (processedStream && processedStream !== streaminfo.stream) {
+                newProcessedStreamId = this.streamManager.registerStream(processedStream, track, {
+                    source: track.source || "stream-processed",
+                    isPreload: false,
+                    priority: 10,
+                });
+            }
             this.currentSlot.resource = resource;
             this.currentSlot.track = track;
             this.currentSlot.streamId = newStreamId;
+            this.currentSlot.processedStreamId = newProcessedStreamId;
             this.currentSlot.isValid = true;
             this.currentResource = resource;
-            // ── Set seek flag BEFORE play so the Buffering handler sees it ────────
             if (position >= 0) {
                 this.seekInProgress = true;
             }
@@ -2231,12 +2239,12 @@ class Player extends events_1.EventEmitter {
         }
         catch (error) {
             this.debug(`[Player] refreshPlayerResource error:`, error);
-            this.seekInProgress = false; // ensure flag is cleared on failure
+            this.seekInProgress = false;
             this.emit("playerError", error, this.queue.currentTrack ?? undefined);
             return false;
         }
         finally {
-            this.refreshLock = false; // always released
+            this.refreshLock = false;
         }
     }
     /**