streamify-audio 2.2.6 → 2.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "streamify-audio",
-  "version": "2.2.6",
+  "version": "2.2.7",
   "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/discord/Stream.js

@@ -192,6 +192,18 @@ class StreamController {
         this.metrics.spawn = Date.now() - spawnStart;
 
         if (this.ytdlp) {
+            this.ffmpeg.stdin.on('error', (err) => {
+                if (err.code !== 'EPIPE' && err.code !== 'ERR_STREAM_DESTROYED') {
+                    log.error('STREAM', `ffmpeg stdin error: ${err.message}`);
+                }
+            });
+
+            this.ytdlp.stdout.on('error', (err) => {
+                if (err.code !== 'EPIPE' && err.code !== 'ERR_STREAM_DESTROYED') {
+                    log.error('STREAM', `yt-dlp stdout error: ${err.message}`);
+                }
+            });
+
             this.ytdlp.stdout.pipe(this.ffmpeg.stdin);
 
             this.ytdlp.stderr.on('data', (data) => {
@@ -232,7 +244,8 @@ class StreamController {
 
         this.resource = createAudioResource(this.ffmpeg.stdout, {
             inputType: StreamType.OggOpus,
-            inlineVolume: false
+            inlineVolume: true,
+            silencePaddingFrames: 10
         });
 
         const elapsed = Date.now() - startTimestamp;
@@ -246,7 +259,6 @@ class StreamController {
     _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();
@@ -258,36 +270,25 @@ class StreamController {
             }, timeoutMs);
 
             let resolved = false;
-            let bufferedSize = 0;
-            let firstByteRecorded = false;
 
-            const checkBuffer = () => {
+            const onReadable = () => {
                 if (resolved) return;
-
-                if (!firstByteRecorded && ffmpeg.stdout && ffmpeg.stdout.readableLength > 0) {
-                    firstByteRecorded = true;
-                    this.metrics.firstByte = Date.now() - (this.startTime + this.metrics.metadata + this.metrics.spawn);
-                }
-
-                bufferedSize = ffmpeg.stdout ? ffmpeg.stdout.readableLength : 0;
-
-                if (bufferedSize >= MIN_BUFFER_SIZE) {
-                    resolved = true;
-                    clearTimeout(timeout);
-                    if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', checkBuffer);
-                    resolve();
-                }
+                resolved = true;
+                this.metrics.firstByte = Date.now() - (this.startTime + this.metrics.metadata + this.metrics.spawn);
+                clearTimeout(timeout);
+                if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', onReadable);
+                resolve();
             };
 
             if (ffmpeg.stdout) {
-                ffmpeg.stdout.on('readable', checkBuffer);
+                ffmpeg.stdout.on('readable', onReadable);
             }
 
             ffmpeg.on('close', () => {
                 if (!resolved) {
                     resolved = true;
                     clearTimeout(timeout);
-                    if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', checkBuffer);
+                    if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', onReadable);
 
                     if (this.destroyed) {
                         return reject(new Error('Stream destroyed during initialization'));
@@ -303,7 +304,7 @@ class StreamController {
                     if (!resolved && code !== 0 && code !== null) {
                         resolved = true;
                         clearTimeout(timeout);
-                        if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', checkBuffer);
+                        if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', onReadable);
 
                         if (this.destroyed) {
                             return reject(new Error('Stream destroyed during initialization'));

package/src/filters/ffmpeg.js

@@ -69,16 +69,12 @@ function buildEqualizer(bands) {
 function buildFfmpegArgs(filters = {}, config = {}) {
     filters = filters || {};
     const args = [
-        '-thread_queue_size', '4096',
-        '-probesize', '128K',
-        '-analyzeduration', '0',
-        '-fflags', '+discardcorrupt',
-        '-copyts',
-        '-start_at_zero',
+        '-thread_queue_size', '512',
         '-i', 'pipe:0',
-        '-vn'
+        '-vn',
+        '-sn'
     ];
-    const audioFilters = ['aresample=async=1:first_pts=0'];
+    const audioFilters = [];
 
     if (filters.equalizer && Array.isArray(filters.equalizer)) {
         const eq = buildEqualizer(filters.equalizer);
@@ -251,9 +247,15 @@ function buildFfmpegArgs(filters = {}, config = {}) {
     }
 
     const bitrate = config.audio?.bitrate || '128k';
-    const format = config.audio?.format || 'opus';
+    const format = config.audio?.format || 'raw';
 
-    if (format === 'opus') {
+    if (format === 'raw' || format === 'pcm') {
+        args.push(
+            '-ar', '48000',
+            '-ac', '2',
+            '-f', 's16le'
+        );
+    } else if (format === 'opus') {
         args.push(
             '-acodec', 'libopus',
             '-b:a', bitrate,
@@ -267,7 +269,7 @@ function buildFfmpegArgs(filters = {}, config = {}) {
     } else if (format === 'aac') {
         args.push('-acodec', 'aac', '-b:a', bitrate, '-f', 'adts');
     } else {
-        args.push('-acodec', 'libopus', '-b:a', bitrate, '-f', 'ogg');
+        args.push('-ar', '48000', '-ac', '2', '-f', 's16le');
     }
 
     args.push('-');

package/src/providers/youtube.js

@@ -64,11 +64,15 @@ async function search(query, limit, config, options = {}) {
                         ?.filter(f => f.vcodec === 'none' && f.acodec !== 'none')
                         .sort((a, b) => (b.abr || 0) - (a.abr || 0))[0];
 
+                    const authorUrl = entry.channel_url || entry.uploader_url ||
+                        (entry.channel_id ? `https://www.youtube.com/channel/${entry.channel_id}` : null);
+
                     return {
                         id: entry.id,
                         title: entry.title,
                         duration: entry.duration || 0,
                         author: entry.channel || entry.uploader,
+                        authorUrl,
                         thumbnail: entry.thumbnails?.[0]?.url,
                         uri: `https://www.youtube.com/watch?v=${entry.id}`,
                         streamUrl: `/youtube/stream/${entry.id}`,
@@ -126,11 +130,15 @@ async function getInfo(videoId, config) {
                     ?.filter(f => f.vcodec === 'none' && f.acodec !== 'none')
                     .sort((a, b) => (b.abr || 0) - (a.abr || 0))[0];
 
+                const authorUrl = data.channel_url || data.uploader_url ||
+                    (data.channel_id ? `https://www.youtube.com/channel/${data.channel_id}` : null);
+
                 resolve({
                     id: data.id,
                     title: data.title,
                     duration: data.duration || 0,
                     author: data.channel || data.uploader,
+                    authorUrl,
                     thumbnail: data.thumbnail,
                     uri: data.webpage_url,
                     streamUrl: `/youtube/stream/${data.id}`,
@@ -279,17 +287,22 @@ async function getPlaylist(playlistId, config) {
             }
             try {
                 const data = JSON.parse(stdout);
-                const tracks = (data.entries || []).map(entry => ({
-                    id: entry.id,
-                    title: entry.title,
-                    duration: entry.duration || 0,
-                    author: entry.channel || entry.uploader,
-                    thumbnail: entry.thumbnails?.[0]?.url,
-                    uri: `https://www.youtube.com/watch?v=${entry.id}`,
-                    streamUrl: `/youtube/stream/${entry.id}`,
-                    source: 'youtube',
-                    isLive: entry.live_status === 'is_live' || entry.is_live === true || !entry.duration
-                }));
+                const tracks = (data.entries || []).map(entry => {
+                    const authorUrl = entry.channel_url || entry.uploader_url ||
+                        (entry.channel_id ? `https://www.youtube.com/channel/${entry.channel_id}` : null);
+                    return {
+                        id: entry.id,
+                        title: entry.title,
+                        duration: entry.duration || 0,
+                        author: entry.channel || entry.uploader,
+                        authorUrl,
+                        thumbnail: entry.thumbnails?.[0]?.url,
+                        uri: `https://www.youtube.com/watch?v=${entry.id}`,
+                        streamUrl: `/youtube/stream/${entry.id}`,
+                        source: 'youtube',
+                        isLive: entry.live_status === 'is_live' || entry.is_live === true || !entry.duration
+                    };
+                });
                 log.info('YOUTUBE', `Playlist loaded: ${data.title || playlistId} (${tracks.length} tracks)`);
                 resolve({
                     id: playlistId,
@@ -342,17 +355,22 @@ async function getRelated(videoId, limit, config) {
                 const tracks = entries
                     .filter(entry => entry.id !== videoId)
                     .slice(0, limit)
-                    .map(entry => ({
-                        id: entry.id,
-                        title: entry.title,
-                        duration: entry.duration,
-                        author: entry.channel || entry.uploader,
-                        thumbnail: entry.thumbnails?.[0]?.url,
-                        uri: `https://www.youtube.com/watch?v=${entry.id}`,
-                        streamUrl: `/youtube/stream/${entry.id}`,
-                        source: 'youtube',
-                        isAutoplay: true
-                    }));
+                    .map(entry => {
+                        const authorUrl = entry.channel_url || entry.uploader_url ||
+                            (entry.channel_id ? `https://www.youtube.com/channel/${entry.channel_id}` : null);
+                        return {
+                            id: entry.id,
+                            title: entry.title,
+                            duration: entry.duration,
+                            author: entry.channel || entry.uploader,
+                            authorUrl,
+                            thumbnail: entry.thumbnails?.[0]?.url,
+                            uri: `https://www.youtube.com/watch?v=${entry.id}`,
+                            streamUrl: `/youtube/stream/${entry.id}`,
+                            source: 'youtube',
+                            isAutoplay: true
+                        };
+                    });
                 log.info('YOUTUBE', `Found ${tracks.length} related tracks`);
                 resolve({ tracks, source: 'youtube' });
             } catch (e) {