vantiv.io 1.0.0

package/src/classes/Actions/lib/AudioStreaming.js

@@ -0,0 +1,447 @@
+const express = require('express');
+const { spawn } = require('child_process');
+const EventEmitter = require('events');
+
+class IcecastStreamer extends EventEmitter {
+    constructor(config = {}) {
+        super();
+        this.config = {
+            server: config.server || 'localhost',
+            port: config.port || 8000,
+            mount: config.mount || '/stream',
+            sourcePassword: config.sourcePassword || 'hackme',
+            audioFormat: config.audioFormat || 'mp3',
+            audioBitrate: config.audioBitrate || '192k',
+            audioSampleRate: config.audioSampleRate || 48000,
+            audioChannels: config.audioChannels || 2,
+            contentType: config.contentType || 'audio/mpeg'
+        };
+        
+        this.ffmpegProcess = null;
+        this.isStreaming = false;
+        this.currentTrack = null;
+        
+        this.icecastUrl = `icecast://source:${this.config.sourcePassword}@${this.config.server}:${this.config.port}${this.config.mount}`;
+        this.publicStreamUrl = `http://${this.config.server}:${this.config.port}${this.config.mount}`;
+        
+    }
+    
+    getFFmpegArgs(url) {
+        return [
+            '-re',
+            '-i', url,
+            '-f', this.config.audioFormat,
+            '-content_type', this.config.contentType,
+            '-vn',
+            '-ar', this.config.audioSampleRate.toString(),
+            '-ac', this.config.audioChannels.toString(),
+            '-b:a', this.config.audioBitrate,
+            this.icecastUrl
+        ];
+    }
+    
+    async streamToIcecast(url, metadata = {}) {
+        if (this.ffmpegProcess) {
+            this.stop();
+            await this.delay(200);
+        }
+        
+        return new Promise((resolve, reject) => {
+            console.log(`Starting Icecast stream for: ${metadata.title || 'Unknown track'}`);
+            
+            this.currentTrack = {
+                url,
+                title: metadata.title || 'Unknown Track',
+                duration: metadata.duration || 0,
+                requester: metadata.requester || 'System',
+                requesterId: metadata.requesterId || 'system',
+                thumbnail: metadata.thumbnail,
+                source: metadata.source || 'stream',
+                startedAt: Date.now()
+            };
+            
+            this.isStreaming = true;
+            
+            const args = this.getFFmpegArgs(url);
+            this.ffmpegProcess = spawn('ffmpeg', args);
+            
+            this.ffmpegProcess.stderr.on('data', (data) => {
+                const message = data.toString();
+                
+                const durationMatch = message.match(/Duration: (\d+):(\d+):(\d+\.\d+)/);
+                if (durationMatch) {
+                    const hours = parseInt(durationMatch[1]);
+                    const minutes = parseInt(durationMatch[2]);
+                    const seconds = parseFloat(durationMatch[3]);
+                    this.currentTrack.duration = hours * 3600 + minutes * 60 + seconds;
+                }
+                
+                const timeMatch = message.match(/time=(\d+):(\d+):(\d+\.\d+)/);
+                if (timeMatch) {
+                    const hours = parseInt(timeMatch[1]);
+                    const minutes = parseInt(timeMatch[2]);
+                    const seconds = parseFloat(timeMatch[3]);
+                    this.currentTrack.position = hours * 3600 + minutes * 60 + seconds;
+                    
+                    this.emit('progress', {
+                        position: this.currentTrack.position,
+                        duration: this.currentTrack.duration,
+                        progress: this.currentTrack.duration > 0 ? 
+                            (this.currentTrack.position / this.currentTrack.duration) * 100 : 0
+                    });
+                }
+                
+                if (message.includes('Stream mapping') || message.includes('Output')) {
+                    console.log('Icecast stream started successfully');
+                    this.emit('playbackStart', this.currentTrack);
+                    resolve();
+                }
+                
+                if (message.includes('Error') || message.includes('Failed')) {
+                    console.error('FFmpeg error:', message.trim());
+                    this.emit('error', new Error(message.trim()));
+                }
+            });
+            
+            this.ffmpegProcess.on('close', (code) => {
+                console.log(`Icecast stream ended with code ${code}`);
+                const endedTrack = this.currentTrack;
+                
+                this.isStreaming = false;
+                this.currentTrack = null;
+                this.ffmpegProcess = null;
+                
+                this.emit('playbackEnd', endedTrack);
+                this.emit('streamEnd', { code, track: endedTrack });
+            });
+            
+            this.ffmpegProcess.on('error', (err) => {
+                console.error('FFmpeg process error:', err);
+                this.isStreaming = false;
+                this.currentTrack = null;
+                reject(err);
+                this.emit('error', err);
+            });
+        });
+    }
+    
+    stop() {
+        if (this.ffmpegProcess) {
+            console.log('Stopping Icecast stream...');
+            this.ffmpegProcess.kill('SIGKILL');
+            this.ffmpegProcess = null;
+            this.isStreaming = false;
+            this.emit('streamStopped');
+        }
+    }
+    
+    getStatus() {
+        return {
+            isStreaming: this.isStreaming,
+            currentTrack: this.currentTrack,
+            config: this.config,
+            publicStreamUrl: this.publicStreamUrl
+        };
+    }
+    
+    getNowPlaying() {
+        if (!this.currentTrack) return null;
+
+        return {
+            track: this.currentTrack,
+            position: this.currentTrack.position || 0,
+            duration: this.currentTrack.duration || 0,
+            progress: this.currentTrack.duration > 0 ? 
+                ((this.currentTrack.position || 0) / this.currentTrack.duration) * 100 : 0,
+            remaining: this.currentTrack.duration > 0 ? 
+                this.currentTrack.duration - (this.currentTrack.position || 0) : 0,
+            elapsed: this.currentTrack.startedAt ? 
+                Math.floor((Date.now() - this.currentTrack.startedAt) / 1000) : 0
+        };
+    }
+    
+    updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+        this.icecastUrl = `icecast://source:${this.config.sourcePassword}@${this.config.server}:${this.config.port}${this.config.mount}`;
+        this.publicStreamUrl = `http://${this.config.server}:${this.config.port}${this.config.mount}`;
+        console.log('Icecast config updated');
+        return this.config;
+    }
+    
+    async delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+
+class Track {
+    constructor(data) {
+        this.id = data.id || Date.now();
+        this.url = data.url;
+        this.title = data.title;
+        this.duration = data.duration;
+        this.requester = data.requester;
+        this.requesterId = data.requesterId;
+        this.addedAt = Date.now();
+        this.thumbnail = data.thumbnail;
+        this.source = data.source;
+    }
+
+    getFormattedDuration() {
+        if (!this.duration) return 'Unknown';
+
+        const hours = Math.floor(this.duration / 3600);
+        const minutes = Math.floor((this.duration % 3600) / 60);
+        const seconds = Math.floor(this.duration % 60);
+
+        if (hours > 0) {
+            return `${hours}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
+        }
+        return `${minutes}:${seconds.toString().padStart(2, '0')}`;
+    }
+}
+
+class IcecastQueue {
+    constructor(streamer, config = {}) {
+        this.queue = [];
+        this.streamer = streamer;
+        this.isProcessing = false;
+        this.currentTrack = null;
+        this.loopMode = 'off';
+        this.history = [];
+        this.maxHistory = config.maxHistory || 50;
+        this.skipRequested = false;
+        
+        this.setupEventListeners();
+    }
+    
+    setupEventListeners() {
+        this.streamer.on('playbackEnd', (track) => {
+            if (track) {
+                this.addToHistory(track, true);
+            }
+            
+            if (this.skipRequested) {
+                this.skipRequested = false;
+                return;
+            }
+            
+            if (this.loopMode === 'track' && track) {
+                this.queue.unshift(new Track({ ...track }));
+            } else if (this.loopMode === 'queue' && track) {
+                this.queue.push(new Track({ ...track }));
+            }
+            
+            setTimeout(() => this.playNext(), 300);
+        });
+        
+        this.streamer.on('playbackStart', (track) => {
+            this.currentTrack = track;
+        });
+    }
+    
+    async add(track) {
+        const isNewTrack = !this.queue.some(q => q.id === track.id);
+        if (!isNewTrack) {
+            return { position: -1, added: false, reason: 'duplicate' };
+        }
+
+        this.queue.push(track);
+        const position = this.queue.length;
+
+        if (!this.streamer.isStreaming && this.queue.length === 1) {
+            await this.playNext();
+            return { position: 1, added: true, isNowPlaying: true };
+        }
+
+        return { position, added: true, isNowPlaying: false };
+    }
+    
+    async addImmediate(track) {
+        if (this.currentTrack) {
+            this.queue.unshift(new Track({ ...this.currentTrack }));
+        }
+        
+        this.queue.unshift(track);
+        await this.skip();
+        return { position: 1, added: true, isNowPlaying: true };
+    }
+    
+    async playNext() {
+        if (this.isProcessing || this.queue.length === 0) {
+            return false;
+        }
+        
+        this.isProcessing = true;
+        
+        try {
+            const nextTrack = this.queue.shift();
+            
+            if (!nextTrack?.url) {
+                setTimeout(() => this.playNext(), 1000);
+                return false;
+            }
+            
+            console.log(`🎵 Playing on Icecast: ${nextTrack.title}`);
+            
+            await this.streamer.streamToIcecast(nextTrack.url, {
+                title: nextTrack.title,
+                duration: nextTrack.duration,
+                requester: nextTrack.requester,
+                requesterId: nextTrack.requesterId,
+                thumbnail: nextTrack.thumbnail,
+                source: nextTrack.source
+            });
+            
+            return true;
+        } catch (error) {
+            console.error('Error playing next track:', error);
+            // Retry with next track
+            setTimeout(() => this.playNext(), 1000);
+            return false;
+        } finally {
+            this.isProcessing = false;
+        }
+    }
+    
+    async skip() {
+        if (!this.streamer.isStreaming) {
+            return false;
+        }
+        
+        this.skipRequested = true;
+        this.streamer.stop();
+        
+        await this.delay(100);
+        await this.playNext();
+        
+        return true;
+    }
+    
+    remove(position) {
+        if (position < 1 || position > this.queue.length) {
+            return null;
+        }
+
+        return this.queue.splice(position - 1, 1)[0];
+    }
+    
+    clear() {
+        const cleared = [...this.queue];
+        this.queue = [];
+        return cleared;
+    }
+    
+    addToHistory(track, success = true) {
+        const historyEntry = {
+            ...track,
+            playedAt: Date.now(),
+            success,
+            endedAt: Date.now()
+        };
+
+        this.history.unshift(historyEntry);
+
+        if (this.history.length > this.maxHistory) {
+            this.history.pop();
+        }
+    }
+    
+    getQueue() {
+        return [...this.queue];
+    }
+    
+    getStatus() {
+        return {
+            isPlaying: this.streamer.isStreaming,
+            currentTrack: this.currentTrack,
+            queueLength: this.queue.length,
+            loopMode: this.loopMode,
+            historyLength: this.history.length,
+            upcoming: this.queue.slice(0, 10)
+        };
+    }
+    
+    async delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+
+class YouTubeExtractor {
+    static async getStreamUrl(youtubeUrl) {
+        return new Promise((resolve) => {
+            const ytdlp = spawn('yt-dlp', [
+                youtubeUrl,
+                '--print', '%(url)s',
+                '--print', '%(title)s',
+                '--print', '%(duration)s',
+                '--print', '%(thumbnail)s',
+                '-f', 'bestaudio[ext=m4a]/bestaudio',
+                '--no-playlist',
+                '--no-check-certificates',
+                '--quiet'
+            ]);
+
+            let data = '';
+            ytdlp.stdout.on('data', (chunk) => data += chunk.toString());
+            ytdlp.stderr.on('data', () => { });
+
+            ytdlp.on('close', (code) => {
+                if (code !== 0) {
+                    resolve(null);
+                    return;
+                }
+
+                const lines = data.trim().split('\n');
+
+                if (lines.length >= 4 && lines[0].startsWith('http')) {
+                    resolve({
+                        url: lines[0],
+                        title: lines[1],
+                        duration: parseInt(lines[2]) || 0,
+                        thumbnail: lines[3] || null,
+                        source: 'youtube'
+                    });
+                } else {
+                    resolve(null);
+                }
+            });
+        });
+    }
+
+    static async searchTrack(query) {
+        return this.getStreamUrl(`ytsearch1:${query}`);
+    }
+}
+
+class IcecastServer {
+    constructor(config = {}) {
+        this.app = express();
+        this.port = config.port || 3000;
+        this.config = config
+        this.logger = config.logger
+        this.setupExpress();
+    }
+    
+    setupExpress() {
+        this.app.use(express.json());
+        
+        this.app.get('/stream', (req, res) => {
+            res.redirect(this.config.publicStreamUrl);
+        });
+    }
+    
+    start() {
+        this.app.listen(this.port, () => {
+            this.logger.success(`IcecastServer.start`, `running: http://localhost:${this.port}`);
+            this.logger.success(`IcecastServer.start`, `Icecast Stream: ${this.config.publicStreamUrl}`);
+        });
+    }
+}
+
+module.exports = {
+    IcecastStreamer,
+    IcecastQueue,
+    Track,
+    YouTubeExtractor,
+    IcecastServer
+};