@jubbio/voice 1.0.0

package/dist/AudioPlayer.js

@@ -0,0 +1,385 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AudioPlayer = void 0;
+exports.createAudioPlayer = createAudioPlayer;
+const events_1 = require("events");
+const child_process_1 = require("child_process");
+const process_1 = require("process");
+const rtc_node_1 = require("@livekit/rtc-node");
+const enums_1 = require("./enums");
+// Audio settings for LiveKit (48kHz stereo)
+const SAMPLE_RATE = 48000;
+const CHANNELS = 2;
+const FRAME_DURATION_MS = 20;
+const SAMPLES_PER_FRAME = (SAMPLE_RATE * FRAME_DURATION_MS) / 1000; // 960
+// Jitter buffer settings
+const FRAME_INTERVAL_NS = BigInt(20_000_000); // 20ms in nanoseconds
+const TARGET_BUFFER_FRAMES = 150; // ~3 seconds - target buffer size
+const MIN_BUFFER_FRAMES = 75; // ~1.5 seconds - minimum before we start
+const MAX_BUFFER_FRAMES = 500; // ~10 seconds - max buffer to prevent memory issues
+const LOW_BUFFER_THRESHOLD = 50; // ~1 second - when to slow down playback
+/**
+ * Audio player for playing audio resources
+ */
+class AudioPlayer extends events_1.EventEmitter {
+    /** Current player state */
+    state = { status: enums_1.AudioPlayerStatus.Idle };
+    /** Player options */
+    options;
+    /** Subscribed voice connections */
+    subscriptions = new Set();
+    /** Current audio resource */
+    currentResource = null;
+    /** FFmpeg process */
+    ffmpegProcess = null;
+    /** LiveKit audio source and track */
+    audioSource = null;
+    audioTrack = null;
+    /** Frame queue and playback state */
+    frameQueue = [];
+    playbackTimeout = null;
+    leftoverBuffer = null;
+    isPublished = false;
+    /** High-resolution timing */
+    nextFrameTime = BigInt(0);
+    isPlaybackLoopRunning = false;
+    ffmpegDone = false;
+    /** Buffer statistics */
+    bufferUnderruns = 0;
+    framesPlayed = 0;
+    constructor(options = {}) {
+        super();
+        this.options = {
+            behaviors: {
+                noSubscriber: 'pause',
+                maxMissedFrames: 5,
+                ...options.behaviors
+            }
+        };
+    }
+    /**
+     * Play an audio resource
+     */
+    play(resource) {
+        // Stop current playback
+        this.stop();
+        this.currentResource = resource;
+        this.setState({ status: enums_1.AudioPlayerStatus.Buffering, resource });
+        // Start playback if we have a ready connection
+        for (const connection of this.subscriptions) {
+            if (connection.getRoom()) {
+                this.startPlayback(connection);
+                break;
+            }
+        }
+    }
+    /**
+     * Pause playback
+     */
+    pause() {
+        if (this.state.status !== enums_1.AudioPlayerStatus.Playing) {
+            return false;
+        }
+        this.setState({ status: enums_1.AudioPlayerStatus.Paused, resource: this.currentResource });
+        return true;
+    }
+    /**
+     * Unpause playback
+     */
+    unpause() {
+        if (this.state.status !== enums_1.AudioPlayerStatus.Paused) {
+            return false;
+        }
+        this.setState({ status: enums_1.AudioPlayerStatus.Playing, resource: this.currentResource });
+        return true;
+    }
+    /**
+     * Stop playback
+     */
+    stop(force = false) {
+        if (this.state.status === enums_1.AudioPlayerStatus.Idle && !force) {
+            return false;
+        }
+        this.cleanup();
+        this.currentResource = null;
+        this.setState({ status: enums_1.AudioPlayerStatus.Idle });
+        return true;
+    }
+    /**
+     * Subscribe a voice connection to this player
+     * @internal
+     */
+    subscribe(connection) {
+        this.subscriptions.add(connection);
+    }
+    /**
+     * Unsubscribe a voice connection from this player
+     * @internal
+     */
+    unsubscribe(connection) {
+        this.subscriptions.delete(connection);
+        // Auto-pause if no subscribers
+        if (this.subscriptions.size === 0 && this.options.behaviors?.noSubscriber === 'pause') {
+            if (this.state.status === enums_1.AudioPlayerStatus.Playing) {
+                this.setState({ status: enums_1.AudioPlayerStatus.AutoPaused, resource: this.currentResource });
+            }
+        }
+    }
+    /**
+     * Called when a connection becomes ready
+     * @internal
+     */
+    onConnectionReady(connection) {
+        // If we have a resource waiting, start playback
+        if (this.currentResource && this.state.status === enums_1.AudioPlayerStatus.Buffering) {
+            this.startPlayback(connection);
+        }
+    }
+    async startPlayback(connection) {
+        const room = connection.getRoom();
+        if (!room || !this.currentResource)
+            return;
+        try {
+            // Create audio source and track
+            await this.setupAudioTrack(room);
+            // Start FFmpeg to decode audio - this will set state to Playing when ready
+            await this.startFFmpeg();
+        }
+        catch (error) {
+            this.emit('error', { message: error.message, resource: this.currentResource });
+            this.stop();
+        }
+    }
+    async setupAudioTrack(room) {
+        if (this.isPublished)
+            return;
+        this.audioSource = new rtc_node_1.AudioSource(SAMPLE_RATE, CHANNELS);
+        this.audioTrack = rtc_node_1.LocalAudioTrack.createAudioTrack('music', this.audioSource);
+        const options = new rtc_node_1.TrackPublishOptions();
+        options.source = rtc_node_1.TrackSource.SOURCE_MICROPHONE;
+        if (room.localParticipant) {
+            await room.localParticipant.publishTrack(this.audioTrack, options);
+        }
+        this.isPublished = true;
+    }
+    async startFFmpeg() {
+        if (!this.currentResource)
+            return;
+        const inputSource = this.currentResource.getInputSource();
+        console.log(`FFmpeg input source: ${inputSource.substring(0, 100)}...`);
+        // Check if this is a streaming URL that needs yt-dlp
+        const needsYtDlp = inputSource.includes('youtube.com') ||
+            inputSource.includes('youtu.be') ||
+            inputSource.includes('soundcloud.com') ||
+            inputSource.includes('twitch.tv') ||
+            inputSource.startsWith('ytsearch:');
+        if (needsYtDlp) {
+            // Use yt-dlp to pipe audio directly to FFmpeg
+            console.log('Using yt-dlp pipe mode');
+            this.ffmpegProcess = (0, child_process_1.spawn)('bash', [
+                '-c',
+                `~/.local/bin/yt-dlp -f "bestaudio/best" -o - --no-playlist --no-warnings "${inputSource}" | ffmpeg -i pipe:0 -f s16le -ar ${SAMPLE_RATE} -ac ${CHANNELS} -acodec pcm_s16le -`
+            ], { stdio: ['pipe', 'pipe', 'pipe'] });
+        }
+        else {
+            console.log('Using direct FFmpeg mode');
+            this.ffmpegProcess = (0, child_process_1.spawn)('ffmpeg', [
+                '-reconnect', '1',
+                '-reconnect_streamed', '1',
+                '-reconnect_delay_max', '5',
+                '-i', inputSource,
+                '-f', 's16le',
+                '-ar', String(SAMPLE_RATE),
+                '-ac', String(CHANNELS),
+                '-acodec', 'pcm_s16le',
+                '-'
+            ], { stdio: ['pipe', 'pipe', 'pipe'] });
+        }
+        const frameSize = SAMPLES_PER_FRAME * CHANNELS * 2;
+        this.ffmpegDone = false;
+        let hasReceivedData = false;
+        this.ffmpegProcess.stdout?.on('data', (chunk) => {
+            if (this.state.status !== enums_1.AudioPlayerStatus.Playing &&
+                this.state.status !== enums_1.AudioPlayerStatus.Buffering)
+                return;
+            hasReceivedData = true;
+            // Handle leftover from previous chunk
+            if (this.leftoverBuffer && this.leftoverBuffer.length > 0) {
+                chunk = Buffer.concat([this.leftoverBuffer, chunk]);
+                this.leftoverBuffer = null;
+            }
+            let offset = 0;
+            while (offset + frameSize <= chunk.length) {
+                const frame = chunk.slice(offset, offset + frameSize);
+                const int16Array = new Int16Array(SAMPLES_PER_FRAME * CHANNELS);
+                for (let i = 0; i < int16Array.length; i++) {
+                    int16Array[i] = frame.readInt16LE(i * 2);
+                }
+                this.frameQueue.push(int16Array);
+                offset += frameSize;
+            }
+            // Save leftover
+            if (offset < chunk.length) {
+                this.leftoverBuffer = chunk.slice(offset);
+            }
+        });
+        let stderrOutput = '';
+        this.ffmpegProcess.stderr?.on('data', (data) => {
+            stderrOutput += data.toString();
+        });
+        this.ffmpegProcess.on('close', (code) => {
+            this.ffmpegDone = true;
+            this.ffmpegProcess = null;
+            if (code !== 0) {
+                console.error(`FFmpeg stderr:\n${stderrOutput}`);
+            }
+            console.log(`[AudioPlayer] FFmpeg closed with code ${code}, hasReceivedData: ${hasReceivedData}, queue: ${this.frameQueue.length}`);
+        });
+        this.ffmpegProcess.on('error', (err) => {
+            console.error('FFmpeg process error:', err.message);
+            this.emit('error', { message: err.message, resource: this.currentResource });
+        });
+        // Wait for initial buffer with timeout
+        const bufferTimeout = 10000; // 10 seconds for initial buffer
+        const startTime = Date.now();
+        while (this.frameQueue.length < MIN_BUFFER_FRAMES && Date.now() - startTime < bufferTimeout) {
+            await new Promise(r => setTimeout(r, 100));
+            // Check if FFmpeg failed early
+            if (this.ffmpegDone && this.frameQueue.length === 0) {
+                throw new Error('FFmpeg failed to produce audio data');
+            }
+        }
+        if (this.frameQueue.length === 0) {
+            throw new Error('Timeout waiting for audio data');
+        }
+        console.log(`[AudioPlayer] Starting playback with ${this.frameQueue.length} frames buffered (target: ${TARGET_BUFFER_FRAMES})`);
+        // Mark ready for playback - setState will trigger the loop
+        this.isPlaybackLoopRunning = true;
+        this.nextFrameTime = process_1.hrtime.bigint();
+        console.log(`[AudioPlayer] Playback ready, audioSource exists: ${!!this.audioSource}`);
+        // Set state to playing - this will trigger scheduleNextFrame via setState
+        this.setState({ status: enums_1.AudioPlayerStatus.Playing, resource: this.currentResource });
+    }
+    /**
+     * High-resolution frame scheduling using hrtime
+     * This provides much more accurate timing than setInterval
+     */
+    scheduleNextFrame() {
+        if (!this.isPlaybackLoopRunning || this.state.status !== enums_1.AudioPlayerStatus.Playing) {
+            console.log(`[AudioPlayer] scheduleNextFrame skipped: loopRunning=${this.isPlaybackLoopRunning}, status=${this.state.status}`);
+            return;
+        }
+        const now = process_1.hrtime.bigint();
+        const delayNs = this.nextFrameTime - now;
+        const delayMs = Number(delayNs) / 1_000_000;
+        if (this.framesPlayed === 0) {
+            console.log(`[AudioPlayer] First frame scheduling: delayMs=${delayMs.toFixed(2)}`);
+        }
+        // Schedule next frame
+        if (delayMs > 1) {
+            this.playbackTimeout = setTimeout(() => this.processFrame(), Math.max(1, delayMs - 1));
+        }
+        else {
+            // We're behind, process immediately
+            setImmediate(() => this.processFrame());
+        }
+    }
+    /**
+     * Process and send a single audio frame
+     */
+    async processFrame() {
+        if (!this.isPlaybackLoopRunning || this.state.status !== enums_1.AudioPlayerStatus.Playing) {
+            if (this.framesPlayed === 0) {
+                console.log(`[AudioPlayer] processFrame skipped: loopRunning=${this.isPlaybackLoopRunning}, status=${this.state.status}`);
+            }
+            return;
+        }
+        // Check buffer status
+        const bufferSize = this.frameQueue.length;
+        if (bufferSize > 0 && this.audioSource) {
+            const int16Array = this.frameQueue.shift();
+            const audioFrame = new rtc_node_1.AudioFrame(int16Array, SAMPLE_RATE, CHANNELS, SAMPLES_PER_FRAME);
+            try {
+                await this.audioSource.captureFrame(audioFrame);
+                this.framesPlayed++;
+                // Log progress every 500 frames (~10 seconds)
+                if (this.framesPlayed % 500 === 0) {
+                    console.log(`[AudioPlayer] Progress: ${this.framesPlayed} frames played, buffer: ${bufferSize}`);
+                }
+            }
+            catch (e) {
+                console.error(`[AudioPlayer] Frame error:`, e.message);
+            }
+            // Update timing for next frame
+            this.nextFrameTime += FRAME_INTERVAL_NS;
+            // Adaptive timing: if buffer is low, slow down slightly to let it recover
+            if (bufferSize < LOW_BUFFER_THRESHOLD && !this.ffmpegDone) {
+                // Add 1ms delay to let buffer recover
+                this.nextFrameTime += BigInt(1_000_000);
+                this.bufferUnderruns++;
+                if (this.bufferUnderruns % 50 === 0) {
+                    console.log(`[AudioPlayer] Buffer low: ${bufferSize} frames, ${this.bufferUnderruns} underruns`);
+                }
+            }
+            // Schedule next frame
+            this.scheduleNextFrame();
+        }
+        else if (this.ffmpegDone && bufferSize === 0) {
+            // Playback finished
+            console.log('[AudioPlayer] Playback finished - queue empty and FFmpeg done');
+            this.stop();
+        }
+        else if (bufferSize === 0) {
+            // Buffer underrun - wait for more data
+            this.bufferUnderruns++;
+            console.log(`[AudioPlayer] Buffer underrun #${this.bufferUnderruns}, waiting for data...`);
+            // Wait a bit and try again
+            this.nextFrameTime = process_1.hrtime.bigint() + BigInt(50_000_000); // 50ms
+            this.scheduleNextFrame();
+        }
+    }
+    cleanup() {
+        // Stop playback loop
+        this.isPlaybackLoopRunning = false;
+        if (this.playbackTimeout) {
+            clearTimeout(this.playbackTimeout);
+            this.playbackTimeout = null;
+        }
+        // Kill FFmpeg
+        if (this.ffmpegProcess) {
+            this.ffmpegProcess.kill('SIGKILL');
+            this.ffmpegProcess = null;
+        }
+        // Clear frame queue
+        this.frameQueue = [];
+        this.leftoverBuffer = null;
+        // Reset timing and state
+        this.nextFrameTime = BigInt(0);
+        this.ffmpegDone = false;
+        // Log stats
+        if (this.framesPlayed > 0) {
+            console.log(`[AudioPlayer] Playback stats: ${this.framesPlayed} frames, ${this.bufferUnderruns} underruns`);
+        }
+        this.bufferUnderruns = 0;
+        this.framesPlayed = 0;
+        // Note: We don't unpublish the track - it stays published for next play
+    }
+    setState(newState) {
+        const oldState = this.state;
+        this.state = newState;
+        this.emit('stateChange', oldState, newState);
+        // Start playback loop when transitioning to Playing
+        if (newState.status === enums_1.AudioPlayerStatus.Playing && oldState.status !== enums_1.AudioPlayerStatus.Playing) {
+            console.log(`[AudioPlayer] State changed to Playing, starting playback loop`);
+            this.scheduleNextFrame();
+        }
+    }
+}
+exports.AudioPlayer = AudioPlayer;
+/**
+ * Create an audio player
+ */
+function createAudioPlayer(options) {
+    return new AudioPlayer(options);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AudioPlayer.js","sourceRoot":"","sources":["../src/AudioPlayer.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter } from 'events';\r\nimport { spawn, ChildProcess } from 'child_process';\r\nimport { hrtime } from 'process';\r\nimport { \r\n  Room, \r\n  LocalAudioTrack, \r\n  AudioSource, \r\n  TrackPublishOptions, \r\n  TrackSource,\r\n  AudioFrame \r\n} from '@livekit/rtc-node';\r\nimport { AudioPlayerStatus } from './enums';\r\nimport { CreateAudioPlayerOptions, AudioPlayerState } from './types';\r\nimport { AudioResource } from './AudioResource';\r\nimport { VoiceConnection } from './VoiceConnection';\r\n\r\n// Audio settings for LiveKit (48kHz stereo)\r\nconst SAMPLE_RATE = 48000;\r\nconst CHANNELS = 2;\r\nconst FRAME_DURATION_MS = 20;\r\nconst SAMPLES_PER_FRAME = (SAMPLE_RATE * FRAME_DURATION_MS) / 1000; // 960\r\n\r\n// Jitter buffer settings\r\nconst FRAME_INTERVAL_NS = BigInt(20_000_000); // 20ms in nanoseconds\r\nconst TARGET_BUFFER_FRAMES = 150; // ~3 seconds - target buffer size\r\nconst MIN_BUFFER_FRAMES = 75;    // ~1.5 seconds - minimum before we start\r\nconst MAX_BUFFER_FRAMES = 500;   // ~10 seconds - max buffer to prevent memory issues\r\nconst LOW_BUFFER_THRESHOLD = 50; // ~1 second - when to slow down playback\r\n\r\n/**\r\n * Audio player for playing audio resources\r\n */\r\nexport class AudioPlayer extends EventEmitter {\r\n  /** Current player state */\r\n  public state: AudioPlayerState = { status: AudioPlayerStatus.Idle };\r\n  \r\n  /** Player options */\r\n  private options: CreateAudioPlayerOptions;\r\n  \r\n  /** Subscribed voice connections */\r\n  private subscriptions: Set<VoiceConnection> = new Set();\r\n  \r\n  /** Current audio resource */\r\n  private currentResource: AudioResource | null = null;\r\n  \r\n  /** FFmpeg process */\r\n  private ffmpegProcess: ChildProcess | null = null;\r\n  \r\n  /** LiveKit audio source and track */\r\n  private audioSource: AudioSource | null = null;\r\n  private audioTrack: LocalAudioTrack | null = null;\r\n  \r\n  /** Frame queue and playback state */\r\n  private frameQueue: Int16Array[] = [];\r\n  private playbackTimeout: NodeJS.Timeout | null = null;\r\n  private leftoverBuffer: Buffer | null = null;\r\n  private isPublished = false;\r\n  \r\n  /** High-resolution timing */\r\n  private nextFrameTime: bigint = BigInt(0);\r\n  private isPlaybackLoopRunning = false;\r\n  private ffmpegDone = false;\r\n  \r\n  /** Buffer statistics */\r\n  private bufferUnderruns = 0;\r\n  private framesPlayed = 0;\r\n\r\n  constructor(options: CreateAudioPlayerOptions = {}) {\r\n    super();\r\n    this.options = {\r\n      behaviors: {\r\n        noSubscriber: 'pause',\r\n        maxMissedFrames: 5,\r\n        ...options.behaviors\r\n      }\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Play an audio resource\r\n   */\r\n  play(resource: AudioResource): void {\r\n    // Stop current playback\r\n    this.stop();\r\n    \r\n    this.currentResource = resource;\r\n    this.setState({ status: AudioPlayerStatus.Buffering, resource });\r\n    \r\n    // Start playback if we have a ready connection\r\n    for (const connection of this.subscriptions) {\r\n      if (connection.getRoom()) {\r\n        this.startPlayback(connection);\r\n        break;\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Pause playback\r\n   */\r\n  pause(): boolean {\r\n    if (this.state.status !== AudioPlayerStatus.Playing) {\r\n      return false;\r\n    }\r\n    this.setState({ status: AudioPlayerStatus.Paused, resource: this.currentResource });\r\n    return true;\r\n  }\r\n\r\n  /**\r\n   * Unpause playback\r\n   */\r\n  unpause(): boolean {\r\n    if (this.state.status !== AudioPlayerStatus.Paused) {\r\n      return false;\r\n    }\r\n    this.setState({ status: AudioPlayerStatus.Playing, resource: this.currentResource });\r\n    return true;\r\n  }\r\n\r\n  /**\r\n   * Stop playback\r\n   */\r\n  stop(force = false): boolean {\r\n    if (this.state.status === AudioPlayerStatus.Idle && !force) {\r\n      return false;\r\n    }\r\n    this.cleanup();\r\n    this.currentResource = null;\r\n    this.setState({ status: AudioPlayerStatus.Idle });\r\n    return true;\r\n  }\r\n\r\n  /**\r\n   * Subscribe a voice connection to this player\r\n   * @internal\r\n   */\r\n  subscribe(connection: VoiceConnection): void {\r\n    this.subscriptions.add(connection);\r\n  }\r\n\r\n  /**\r\n   * Unsubscribe a voice connection from this player\r\n   * @internal\r\n   */\r\n  unsubscribe(connection: VoiceConnection): void {\r\n    this.subscriptions.delete(connection);\r\n    \r\n    // Auto-pause if no subscribers\r\n    if (this.subscriptions.size === 0 && this.options.behaviors?.noSubscriber === 'pause') {\r\n      if (this.state.status === AudioPlayerStatus.Playing) {\r\n        this.setState({ status: AudioPlayerStatus.AutoPaused, resource: this.currentResource });\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Called when a connection becomes ready\r\n   * @internal\r\n   */\r\n  onConnectionReady(connection: VoiceConnection): void {\r\n    // If we have a resource waiting, start playback\r\n    if (this.currentResource && this.state.status === AudioPlayerStatus.Buffering) {\r\n      this.startPlayback(connection);\r\n    }\r\n  }\r\n\r\n  private async startPlayback(connection: VoiceConnection): Promise<void> {\r\n    const room = connection.getRoom();\r\n    if (!room || !this.currentResource) return;\r\n\r\n    try {\r\n      // Create audio source and track\r\n      await this.setupAudioTrack(room);\r\n      \r\n      // Start FFmpeg to decode audio - this will set state to Playing when ready\r\n      await this.startFFmpeg();\r\n    } catch (error) {\r\n      this.emit('error', { message: (error as Error).message, resource: this.currentResource });\r\n      this.stop();\r\n    }\r\n  }\r\n\r\n  private async setupAudioTrack(room: Room): Promise<void> {\r\n    if (this.isPublished) return;\r\n    \r\n    this.audioSource = new AudioSource(SAMPLE_RATE, CHANNELS);\r\n    this.audioTrack = LocalAudioTrack.createAudioTrack('music', this.audioSource);\r\n    \r\n    const options = new TrackPublishOptions();\r\n    options.source = TrackSource.SOURCE_MICROPHONE;\r\n    \r\n    if (room.localParticipant) {\r\n      await room.localParticipant.publishTrack(this.audioTrack, options);\r\n    }\r\n    this.isPublished = true;\r\n  }\r\n\r\n  private async startFFmpeg(): Promise<void> {\r\n    if (!this.currentResource) return;\r\n    \r\n    const inputSource = this.currentResource.getInputSource();\r\n    console.log(`FFmpeg input source: ${inputSource.substring(0, 100)}...`);\r\n    \r\n    // Check if this is a streaming URL that needs yt-dlp\r\n    const needsYtDlp = inputSource.includes('youtube.com') || \r\n                       inputSource.includes('youtu.be') ||\r\n                       inputSource.includes('soundcloud.com') ||\r\n                       inputSource.includes('twitch.tv') ||\r\n                       inputSource.startsWith('ytsearch:');\r\n    \r\n    if (needsYtDlp) {\r\n      // Use yt-dlp to pipe audio directly to FFmpeg\r\n      console.log('Using yt-dlp pipe mode');\r\n      this.ffmpegProcess = spawn('bash', [\r\n        '-c',\r\n        `~/.local/bin/yt-dlp -f \"bestaudio/best\" -o - --no-playlist --no-warnings \"${inputSource}\" | ffmpeg -i pipe:0 -f s16le -ar ${SAMPLE_RATE} -ac ${CHANNELS} -acodec pcm_s16le -`\r\n      ], { stdio: ['pipe', 'pipe', 'pipe'] });\r\n    } else {\r\n      console.log('Using direct FFmpeg mode');\r\n      this.ffmpegProcess = spawn('ffmpeg', [\r\n        '-reconnect', '1',\r\n        '-reconnect_streamed', '1',\r\n        '-reconnect_delay_max', '5',\r\n        '-i', inputSource,\r\n        '-f', 's16le',\r\n        '-ar', String(SAMPLE_RATE),\r\n        '-ac', String(CHANNELS),\r\n        '-acodec', 'pcm_s16le',\r\n        '-'\r\n      ], { stdio: ['pipe', 'pipe', 'pipe'] });\r\n    }\r\n\r\n    const frameSize = SAMPLES_PER_FRAME * CHANNELS * 2;\r\n    this.ffmpegDone = false;\r\n    let hasReceivedData = false;\r\n\r\n    this.ffmpegProcess.stdout?.on('data', (chunk: Buffer) => {\r\n      if (this.state.status !== AudioPlayerStatus.Playing && \r\n          this.state.status !== AudioPlayerStatus.Buffering) return;\r\n      \r\n      hasReceivedData = true;\r\n      \r\n      // Handle leftover from previous chunk\r\n      if (this.leftoverBuffer && this.leftoverBuffer.length > 0) {\r\n        chunk = Buffer.concat([this.leftoverBuffer, chunk]);\r\n        this.leftoverBuffer = null;\r\n      }\r\n      \r\n      let offset = 0;\r\n      while (offset + frameSize <= chunk.length) {\r\n        const frame = chunk.slice(offset, offset + frameSize);\r\n        const int16Array = new Int16Array(SAMPLES_PER_FRAME * CHANNELS);\r\n        \r\n        for (let i = 0; i < int16Array.length; i++) {\r\n          int16Array[i] = frame.readInt16LE(i * 2);\r\n        }\r\n        \r\n        this.frameQueue.push(int16Array);\r\n        offset += frameSize;\r\n      }\r\n      \r\n      // Save leftover\r\n      if (offset < chunk.length) {\r\n        this.leftoverBuffer = chunk.slice(offset);\r\n      }\r\n    });\r\n\r\n    let stderrOutput = '';\r\n    this.ffmpegProcess.stderr?.on('data', (data: Buffer) => {\r\n      stderrOutput += data.toString();\r\n    });\r\n\r\n    this.ffmpegProcess.on('close', (code) => {\r\n      this.ffmpegDone = true;\r\n      this.ffmpegProcess = null;\r\n      if (code !== 0) {\r\n        console.error(`FFmpeg stderr:\\n${stderrOutput}`);\r\n      }\r\n      console.log(`[AudioPlayer] FFmpeg closed with code ${code}, hasReceivedData: ${hasReceivedData}, queue: ${this.frameQueue.length}`);\r\n    });\r\n\r\n    this.ffmpegProcess.on('error', (err) => {\r\n      console.error('FFmpeg process error:', err.message);\r\n      this.emit('error', { message: err.message, resource: this.currentResource });\r\n    });\r\n\r\n    // Wait for initial buffer with timeout\r\n    const bufferTimeout = 10000; // 10 seconds for initial buffer\r\n    const startTime = Date.now();\r\n    \r\n    while (this.frameQueue.length < MIN_BUFFER_FRAMES && Date.now() - startTime < bufferTimeout) {\r\n      await new Promise(r => setTimeout(r, 100));\r\n      \r\n      // Check if FFmpeg failed early\r\n      if (this.ffmpegDone && this.frameQueue.length === 0) {\r\n        throw new Error('FFmpeg failed to produce audio data');\r\n      }\r\n    }\r\n    \r\n    if (this.frameQueue.length === 0) {\r\n      throw new Error('Timeout waiting for audio data');\r\n    }\r\n    \r\n    console.log(`[AudioPlayer] Starting playback with ${this.frameQueue.length} frames buffered (target: ${TARGET_BUFFER_FRAMES})`);\r\n\r\n    // Mark ready for playback - setState will trigger the loop\r\n    this.isPlaybackLoopRunning = true;\r\n    this.nextFrameTime = hrtime.bigint();\r\n    console.log(`[AudioPlayer] Playback ready, audioSource exists: ${!!this.audioSource}`);\r\n    \r\n    // Set state to playing - this will trigger scheduleNextFrame via setState\r\n    this.setState({ status: AudioPlayerStatus.Playing, resource: this.currentResource });\r\n  }\r\n\r\n  /**\r\n   * High-resolution frame scheduling using hrtime\r\n   * This provides much more accurate timing than setInterval\r\n   */\r\n  private scheduleNextFrame(): void {\r\n    if (!this.isPlaybackLoopRunning || this.state.status !== AudioPlayerStatus.Playing) {\r\n      console.log(`[AudioPlayer] scheduleNextFrame skipped: loopRunning=${this.isPlaybackLoopRunning}, status=${this.state.status}`);\r\n      return;\r\n    }\r\n\r\n    const now = hrtime.bigint();\r\n    const delayNs = this.nextFrameTime - now;\r\n    const delayMs = Number(delayNs) / 1_000_000;\r\n\r\n    if (this.framesPlayed === 0) {\r\n      console.log(`[AudioPlayer] First frame scheduling: delayMs=${delayMs.toFixed(2)}`);\r\n    }\r\n\r\n    // Schedule next frame\r\n    if (delayMs > 1) {\r\n      this.playbackTimeout = setTimeout(() => this.processFrame(), Math.max(1, delayMs - 1));\r\n    } else {\r\n      // We're behind, process immediately\r\n      setImmediate(() => this.processFrame());\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Process and send a single audio frame\r\n   */\r\n  private async processFrame(): Promise<void> {\r\n    if (!this.isPlaybackLoopRunning || this.state.status !== AudioPlayerStatus.Playing) {\r\n      if (this.framesPlayed === 0) {\r\n        console.log(`[AudioPlayer] processFrame skipped: loopRunning=${this.isPlaybackLoopRunning}, status=${this.state.status}`);\r\n      }\r\n      return;\r\n    }\r\n\r\n    // Check buffer status\r\n    const bufferSize = this.frameQueue.length;\r\n    \r\n    if (bufferSize > 0 && this.audioSource) {\r\n      const int16Array = this.frameQueue.shift()!;\r\n      const audioFrame = new AudioFrame(int16Array, SAMPLE_RATE, CHANNELS, SAMPLES_PER_FRAME);\r\n      \r\n      try {\r\n        await this.audioSource.captureFrame(audioFrame);\r\n        this.framesPlayed++;\r\n        \r\n        // Log progress every 500 frames (~10 seconds)\r\n        if (this.framesPlayed % 500 === 0) {\r\n          console.log(`[AudioPlayer] Progress: ${this.framesPlayed} frames played, buffer: ${bufferSize}`);\r\n        }\r\n      } catch (e) {\r\n        console.error(`[AudioPlayer] Frame error:`, (e as Error).message);\r\n      }\r\n      \r\n      // Update timing for next frame\r\n      this.nextFrameTime += FRAME_INTERVAL_NS;\r\n      \r\n      // Adaptive timing: if buffer is low, slow down slightly to let it recover\r\n      if (bufferSize < LOW_BUFFER_THRESHOLD && !this.ffmpegDone) {\r\n        // Add 1ms delay to let buffer recover\r\n        this.nextFrameTime += BigInt(1_000_000);\r\n        this.bufferUnderruns++;\r\n        \r\n        if (this.bufferUnderruns % 50 === 0) {\r\n          console.log(`[AudioPlayer] Buffer low: ${bufferSize} frames, ${this.bufferUnderruns} underruns`);\r\n        }\r\n      }\r\n      \r\n      // Schedule next frame\r\n      this.scheduleNextFrame();\r\n      \r\n    } else if (this.ffmpegDone && bufferSize === 0) {\r\n      // Playback finished\r\n      console.log('[AudioPlayer] Playback finished - queue empty and FFmpeg done');\r\n      this.stop();\r\n    } else if (bufferSize === 0) {\r\n      // Buffer underrun - wait for more data\r\n      this.bufferUnderruns++;\r\n      console.log(`[AudioPlayer] Buffer underrun #${this.bufferUnderruns}, waiting for data...`);\r\n      \r\n      // Wait a bit and try again\r\n      this.nextFrameTime = hrtime.bigint() + BigInt(50_000_000); // 50ms\r\n      this.scheduleNextFrame();\r\n    }\r\n  }\r\n\r\n  private cleanup(): void {\r\n    // Stop playback loop\r\n    this.isPlaybackLoopRunning = false;\r\n    if (this.playbackTimeout) {\r\n      clearTimeout(this.playbackTimeout);\r\n      this.playbackTimeout = null;\r\n    }\r\n    \r\n    // Kill FFmpeg\r\n    if (this.ffmpegProcess) {\r\n      this.ffmpegProcess.kill('SIGKILL');\r\n      this.ffmpegProcess = null;\r\n    }\r\n    \r\n    // Clear frame queue\r\n    this.frameQueue = [];\r\n    this.leftoverBuffer = null;\r\n    \r\n    // Reset timing and state\r\n    this.nextFrameTime = BigInt(0);\r\n    this.ffmpegDone = false;\r\n    \r\n    // Log stats\r\n    if (this.framesPlayed > 0) {\r\n      console.log(`[AudioPlayer] Playback stats: ${this.framesPlayed} frames, ${this.bufferUnderruns} underruns`);\r\n    }\r\n    this.bufferUnderruns = 0;\r\n    this.framesPlayed = 0;\r\n    \r\n    // Note: We don't unpublish the track - it stays published for next play\r\n  }\r\n\r\n  private setState(newState: AudioPlayerState): void {\r\n    const oldState = this.state;\r\n    this.state = newState;\r\n    this.emit('stateChange', oldState, newState);\r\n    \r\n    // Start playback loop when transitioning to Playing\r\n    if (newState.status === AudioPlayerStatus.Playing && oldState.status !== AudioPlayerStatus.Playing) {\r\n      console.log(`[AudioPlayer] State changed to Playing, starting playback loop`);\r\n      this.scheduleNextFrame();\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Create an audio player\r\n */\r\nexport function createAudioPlayer(options?: CreateAudioPlayerOptions): AudioPlayer {\r\n  return new AudioPlayer(options);\r\n}\r\n"]}

package/dist/AudioResource.d.ts

@@ -0,0 +1,60 @@
+import { CreateAudioResourceOptions, AudioResourceInput } from './types';
+/**
+ * Represents an audio resource that can be played
+ */
+export declare class AudioResource<T = unknown> {
+    /** Metadata attached to this resource */
+    readonly metadata: T;
+    /** Whether playback has started */
+    started: boolean;
+    /** Whether playback has ended */
+    ended: boolean;
+    /** The input source (URL or file path) */
+    private inputSource;
+    /** Stream type */
+    private streamType;
+    /** Volume (0-1) */
+    private volume;
+    constructor(input: AudioResourceInput, options?: CreateAudioResourceOptions<T>);
+    /**
+     * Get the input source for FFmpeg
+     * @internal
+     */
+    getInputSource(): string;
+    /**
+     * Set the volume (0-1)
+     */
+    setVolume(volume: number): void;
+    /**
+     * Get the current volume
+     */
+    getVolume(): number;
+}
+/**
+ * Options for creating audio resource from URL
+ */
+export interface CreateAudioResourceFromUrlOptions<T = unknown> extends CreateAudioResourceOptions<T> {
+    /** Use yt-dlp to extract audio URL */
+    useYtDlp?: boolean;
+    /** Path to yt-dlp binary */
+    ytDlpPath?: string;
+}
+/**
+ * Create an audio resource from various inputs
+ */
+export declare function createAudioResource<T = unknown>(input: AudioResourceInput, options?: CreateAudioResourceOptions<T>): AudioResource<T>;
+/**
+ * Create an audio resource from a YouTube/streaming URL
+ * Stores the original URL - extraction happens at playback time
+ */
+export declare function createAudioResourceFromUrl<T = unknown>(url: string, options?: CreateAudioResourceFromUrlOptions<T>): AudioResource<T>;
+/**
+ * Probe audio info from a URL or search query
+ * If input is not a URL, it will search YouTube
+ */
+export declare function probeAudioInfo(input: string, ytDlpPath?: string): Promise<{
+    title: string;
+    duration: number;
+    thumbnail?: string;
+    url: string;
+}>;