@spatius/avatarkit 1.3.1-beta.2 → 1.3.1-beta.4

package/dist/StreamingAudioPlayer-DmotFnXu.js

@@ -0,0 +1,561 @@
+import { c as logEvent, t as logger } from "./logger-C3fw-NWP.js";
+import { n as APP_CONFIG, t as errorToMessage } from "./error-utils-PtNzUHiL.js";
+//#region audio/StreamingAudioPlayer.ts
+/**
+* Streaming Audio Player
+* Implements real-time audio playback using Web Audio API
+* Supports dynamic PCM chunk addition without Workers
+* @internal
+*/
+/**
+* @internal
+*/
+var StreamingAudioPlayer = class {
+	audioContext = null;
+	sampleRate;
+	channelCount;
+	debug;
+	sessionId;
+	sessionStartTime = 0;
+	pausedTimeOffset = 0;
+	pausedAt = 0;
+	pausedAudioContextTime = 0;
+	scheduledTime = 0;
+	isPlaying = false;
+	isPaused = false;
+	autoStartEnabled = true;
+	autoContinue = false;
+	audioChunks = [];
+	scheduledChunks = 0;
+	activeSources = /* @__PURE__ */ new Set();
+	lastScheduledChunkEndTime = 0;
+	lastGetCurrentTimeLog = 0;
+	scheduledChunkInfo = [];
+	gainNode = null;
+	volume = 1;
+	onEndedCallback;
+	onAudioStallCallback;
+	stateChangeHandler;
+	isResuming = false;
+	constructor(options) {
+		this.sessionId = `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+		this.sampleRate = options?.sampleRate ?? APP_CONFIG.audio.sampleRate;
+		this.channelCount = options?.channelCount ?? 1;
+		this.debug = options?.debug ?? false;
+	}
+	/**
+	* Initialize audio context (create and ensure it's ready)
+	*/
+	async initialize() {
+		if (this.audioContext) return;
+		try {
+			this.audioContext = new AudioContext({ sampleRate: this.sampleRate });
+			this.gainNode = this.audioContext.createGain();
+			this.gainNode.gain.value = this.volume;
+			this.gainNode.connect(this.audioContext.destination);
+			if (this.audioContext.state === "suspended") await this.audioContext.resume();
+			this.stateChangeHandler = (event) => {
+				if (event.target.state === "suspended" && this.isPlaying && !this.isPaused) this.ensureAudioContextRunning().catch((err) => {
+					logger.error("[StreamingAudioPlayer] Failed to auto-resume AudioContext after external suspend:", err);
+				});
+			};
+			this.audioContext.addEventListener("statechange", this.stateChangeHandler);
+			this.log("AudioContext initialized", {
+				sessionId: this.sessionId,
+				sampleRate: this.audioContext.sampleRate,
+				state: this.audioContext.state
+			});
+		} catch (error) {
+			const message = errorToMessage(error);
+			logEvent("audio_session_init_failed", "warning", {
+				session_id: this.sessionId,
+				reason: message
+			});
+			logger.error("Failed to initialize AudioContext:", message);
+			throw error instanceof Error ? error : new Error(message);
+		}
+	}
+	/**
+	* Ensure AudioContext is running (auto-resume if suspended)
+	* Only auto-resume when playing and not paused, avoid interfering with normal pause/resume logic
+	* 
+	* Optimizations:
+	* - Fast path: if already in running state, return directly
+	* - Avoid concurrent resume: use isResuming flag to prevent duplicate resume requests
+	* - Handle closed state: if AudioContext is closed, cannot resume
+	* @internal
+	*/
+	async ensureAudioContextRunning() {
+		if (!this.audioContext) return;
+		const state = this.audioContext.state;
+		if (state === "running") return;
+		if (state === "closed") {
+			this.log("AudioContext is closed, cannot resume", {
+				sessionId: this.sessionId,
+				state
+			});
+			return;
+		}
+		if (state === "suspended" && this.isPlaying && !this.isPaused) {
+			if (this.isResuming) {
+				this.log("AudioContext resume already in progress, skipping duplicate request", {
+					sessionId: this.sessionId,
+					state
+				});
+				return;
+			}
+			this.isResuming = true;
+			try {
+				this.log("AudioContext is suspended during playback, resuming...", {
+					sessionId: this.sessionId,
+					state,
+					isPlaying: this.isPlaying,
+					isPaused: this.isPaused
+				});
+				await this.audioContext.resume();
+				this.log("AudioContext resumed successfully", {
+					sessionId: this.sessionId,
+					state: this.audioContext.state
+				});
+			} catch (err) {
+				logger.error("[StreamingAudioPlayer] Failed to resume AudioContext:", err);
+				logEvent("audio_context_resume_failed", "error", {
+					session_id: this.sessionId,
+					reason: err instanceof Error ? err.message : String(err)
+				});
+			} finally {
+				this.isResuming = false;
+			}
+		}
+	}
+	/**
+	* Add audio chunk (16-bit PCM)
+	*/
+	addChunk(pcmData, isLast = false) {
+		if (!this.audioContext) {
+			logger.error("AudioContext not initialized");
+			return;
+		}
+		if (this.isPlaying && !this.isPaused && this.audioContext.state === "suspended") this.ensureAudioContextRunning().catch((err) => {
+			logger.error("[StreamingAudioPlayer] Failed to ensure AudioContext running in addChunk:", err);
+		});
+		this.audioChunks.push({
+			data: pcmData,
+			isLast
+		});
+		if (this.isPlaying && this.audioChunks.length === this.scheduledChunks) {}
+		this.log(`Added chunk ${this.audioChunks.length}`, {
+			size: pcmData.length,
+			totalChunks: this.audioChunks.length,
+			isLast,
+			isPlaying: this.isPlaying,
+			scheduledChunks: this.scheduledChunks
+		});
+		if (this.autoContinue && this.isPaused) {
+			this.log("[StreamingAudioPlayer] autoContinue=true, auto-resuming playback");
+			this.autoContinue = false;
+			this.onAudioStallCallback?.(false);
+			this.resume().catch((err) => {
+				logger.error("Failed to auto-resume playback:", err);
+			});
+		}
+		if (!this.isPlaying && this.autoStartEnabled && this.audioChunks.length > 0) {
+			this.log("[StreamingAudioPlayer] Auto-starting playback from addChunk");
+			this.startPlayback().catch((err) => {
+				logger.error("[StreamingAudioPlayer] Failed to start playback from addChunk:", err);
+			});
+		} else if (this.isPlaying && !this.isPaused) {
+			this.log("[StreamingAudioPlayer] Already playing, scheduling next chunk");
+			this.scheduleNextChunk();
+		} else this.log("[StreamingAudioPlayer] Not playing and no chunks, waiting for more chunks");
+	}
+	/**
+	* Start new session (stop current and start fresh)
+	*/
+	async startNewSession(audioChunks, leadingSilenceMs = 0) {
+		this.stop();
+		this.sessionId = `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+		this.audioChunks = [];
+		this.scheduledChunks = 0;
+		this.pausedTimeOffset = 0;
+		this.pausedAt = 0;
+		this.pausedAudioContextTime = 0;
+		this.autoContinue = false;
+		this.log("Starting new session", {
+			chunks: audioChunks.length,
+			leadingSilenceMs
+		});
+		if (leadingSilenceMs > 0) {
+			const silenceSamples = Math.floor(leadingSilenceMs / 1e3 * this.sampleRate) * this.channelCount;
+			const silencePcm = new Uint8Array(silenceSamples * 2);
+			this.addChunk(silencePcm, false);
+		}
+		for (const chunk of audioChunks) this.addChunk(chunk.data, chunk.isLast);
+	}
+	/**
+	* Start playback
+	*/
+	async startPlayback() {
+		if (!this.audioContext) {
+			this.log("[StreamingAudioPlayer] Cannot start playback: AudioContext not initialized");
+			return;
+		}
+		if (this.isPlaying) {
+			this.log("[StreamingAudioPlayer] Cannot start playback: Already playing");
+			return;
+		}
+		this.isPlaying = true;
+		this.sessionStartTime = this.audioContext.currentTime;
+		this.scheduledTime = this.sessionStartTime;
+		this.lastScheduledChunkEndTime = 0;
+		this.scheduledChunkInfo = [];
+		this.autoContinue = false;
+		await this.ensureAudioContextRunning();
+		this.log("[StreamingAudioPlayer] Starting playback", {
+			sessionStartTime: this.sessionStartTime,
+			bufferedChunks: this.audioChunks.length,
+			scheduledChunks: this.scheduledChunks,
+			activeSources: this.activeSources.size,
+			audioContextState: this.audioContext.state
+		});
+		this.scheduleAllChunks();
+	}
+	/**
+	* Schedule all pending chunks
+	*/
+	scheduleAllChunks() {
+		while (this.scheduledChunks < this.audioChunks.length) this.scheduleNextChunk();
+	}
+	/**
+	* Schedule next audio chunk
+	*/
+	scheduleNextChunk() {
+		if (!this.audioContext) {
+			this.log("[StreamingAudioPlayer] Cannot schedule chunk: AudioContext not initialized");
+			return;
+		}
+		if (!this.isPlaying || this.isPaused) {
+			this.log("[StreamingAudioPlayer] Cannot schedule chunk: Not playing or paused");
+			return;
+		}
+		if (this.audioContext.state === "suspended") this.ensureAudioContextRunning().catch((err) => {
+			logger.error("[StreamingAudioPlayer] Failed to ensure AudioContext running in scheduleNextChunk:", err);
+		});
+		const chunkIndex = this.scheduledChunks;
+		if (chunkIndex >= this.audioChunks.length) {
+			this.log(`[StreamingAudioPlayer] No more chunks to schedule (chunkIndex: ${chunkIndex}, totalChunks: ${this.audioChunks.length})`);
+			return;
+		}
+		const chunk = this.audioChunks[chunkIndex];
+		if (chunk.data.length === 0 && !chunk.isLast) {
+			this.scheduledChunks++;
+			return;
+		}
+		const pcmData = chunk.data;
+		const isLast = chunk.isLast;
+		const audioBuffer = this.pcmToAudioBuffer(pcmData);
+		if (!audioBuffer) {
+			logger.error("Failed to create AudioBuffer from PCM data");
+			logEvent("audio_buffer_creation_failed", "error", { session_id: this.sessionId });
+			return;
+		}
+		try {
+			const source = this.audioContext.createBufferSource();
+			source.buffer = audioBuffer;
+			source.connect(this.gainNode);
+			const chunkStartTime = this.scheduledTime;
+			source.start(chunkStartTime);
+			const actualStartTime = Math.max(chunkStartTime, this.audioContext.currentTime);
+			this.scheduledChunkInfo.push({
+				startTime: actualStartTime,
+				duration: audioBuffer.duration
+			});
+			this.activeSources.add(source);
+			source.onended = () => {
+				this.activeSources.delete(source);
+				if (this.activeSources.size === 0) if (!!!this.audioChunks[this.scheduledChunks - 1]?.isLast) {
+					this.log("All audio chunks ended but end=false, pausing and setting autoContinue");
+					this.onAudioStallCallback?.(true);
+					this.autoContinue = true;
+					this.pause();
+				} else {
+					this.log("Last audio chunk ended, marking playback as ended");
+					this.markEnded();
+				}
+			};
+			this.scheduledTime += audioBuffer.duration;
+			this.lastScheduledChunkEndTime = this.scheduledTime - this.sessionStartTime - this.pausedTimeOffset;
+			this.scheduledChunks++;
+			this.log(`[StreamingAudioPlayer] Scheduled chunk ${chunkIndex + 1}/${this.audioChunks.length}`, {
+				startTime: this.scheduledTime - audioBuffer.duration,
+				duration: audioBuffer.duration,
+				nextScheduleTime: this.scheduledTime,
+				isLast,
+				activeSources: this.activeSources.size
+			});
+		} catch (err) {
+			logger.error("Failed to schedule audio chunk:", err);
+			logEvent("schedule_chunk_failed", "error", {
+				session_id: this.sessionId,
+				reason: err instanceof Error ? err.message : String(err)
+			});
+		}
+	}
+	/**
+	* Convert PCM data to AudioBuffer
+	* Input: 16-bit PCM (int16), Output: AudioBuffer (float32 [-1, 1])
+	*/
+	pcmToAudioBuffer(pcmData) {
+		if (!this.audioContext) return null;
+		if (pcmData.length === 0) {
+			const numSamples = Math.floor(this.sampleRate * .01);
+			const audioBuffer = this.audioContext.createBuffer(this.channelCount, numSamples, this.sampleRate);
+			for (let channel = 0; channel < this.channelCount; channel++) audioBuffer.getChannelData(channel).fill(0);
+			return audioBuffer;
+		}
+		const alignedData = new Uint8Array(pcmData);
+		const int16Array = new Int16Array(alignedData.buffer, 0, alignedData.length / 2);
+		const numSamples = int16Array.length / this.channelCount;
+		const audioBuffer = this.audioContext.createBuffer(this.channelCount, numSamples, this.sampleRate);
+		for (let channel = 0; channel < this.channelCount; channel++) {
+			const channelData = audioBuffer.getChannelData(channel);
+			for (let i = 0; i < numSamples; i++) channelData[i] = int16Array[i * this.channelCount + channel] / 32768;
+		}
+		return audioBuffer;
+	}
+	/**
+	* Get current playback time (seconds)
+	* Returns total actual playback duration
+	* @internal
+	*/
+	getCurrentTime() {
+		if (!this.audioContext || !this.isPlaying) return 0;
+		if (this.isPaused) return this.pausedAt;
+		const currentAudioTime = this.audioContext.currentTime;
+		if (this.activeSources.size === 0 && this.scheduledChunks > 0) return Math.max(0, this.lastScheduledChunkEndTime);
+		let totalPlayedDuration = 0;
+		for (let i = 0; i < this.scheduledChunkInfo.length; i++) {
+			const chunkInfo = this.scheduledChunkInfo[i];
+			const chunkEndTime = chunkInfo.startTime + chunkInfo.duration;
+			if (currentAudioTime < chunkInfo.startTime) break;
+			else if (chunkEndTime <= currentAudioTime) totalPlayedDuration += chunkInfo.duration;
+			else {
+				const playedTime = currentAudioTime - chunkInfo.startTime;
+				totalPlayedDuration += playedTime;
+				break;
+			}
+		}
+		return Math.max(0, totalPlayedDuration);
+	}
+	/**
+	* Get total duration of buffered audio (seconds)
+	* Calculate total duration of all buffered chunks
+	* @internal
+	*/
+	getBufferedDuration() {
+		if (!this.audioContext) return 0;
+		let totalDuration = 0;
+		for (const chunk of this.audioChunks) {
+			const chunkDuration = chunk.data.length / (this.sampleRate * this.channelCount * 2);
+			totalDuration += chunkDuration;
+		}
+		return totalDuration;
+	}
+	/**
+	* Get current AudioContext time
+	* @returns Current AudioContext time in seconds, or 0 if AudioContext is not initialized
+	*/
+	getAudioContextTime() {
+		return this.audioContext?.currentTime ?? 0;
+	}
+	/**
+	* Pause playback
+	*/
+	pause() {
+		if (!this.isPlaying || this.isPaused || !this.audioContext) return;
+		this.pausedAt = this.getCurrentTime();
+		this.pausedAudioContextTime = this.audioContext.currentTime;
+		this.isPaused = true;
+		if (this.audioContext.state === "running") this.audioContext.suspend().catch((err) => {
+			logger.error("Failed to suspend AudioContext:", err);
+			this.isPaused = false;
+		});
+		this.log("Playback paused", {
+			pausedAt: this.pausedAt,
+			pausedAudioContextTime: this.pausedAudioContextTime,
+			audioContextState: this.audioContext.state
+		});
+	}
+	/**
+	* Resume playback
+	*/
+	async resume() {
+		if (!this.isPaused || !this.audioContext || !this.isPlaying) return;
+		this.autoContinue = false;
+		if (this.audioContext.state === "suspended") try {
+			await this.audioContext.resume();
+		} catch (err) {
+			logger.error("Failed to resume AudioContext:", err);
+			throw err;
+		}
+		const currentAudioTime = this.audioContext.currentTime;
+		this.sessionStartTime = this.pausedAudioContextTime - this.pausedAt - this.pausedTimeOffset;
+		this.isPaused = false;
+		if (this.scheduledChunks < this.audioChunks.length) this.scheduleAllChunks();
+		this.log("Playback resumed", {
+			pausedAt: this.pausedAt,
+			pausedAudioContextTime: this.pausedAudioContextTime,
+			currentAudioContextTime: currentAudioTime,
+			adjustedSessionStartTime: this.sessionStartTime,
+			audioContextState: this.audioContext.state
+		});
+	}
+	/**
+	* Stop playback
+	*/
+	stop() {
+		if (!this.audioContext) return;
+		if (this.isPaused && this.audioContext.state === "suspended") {
+			this.audioContext.resume().catch(() => {});
+			this.isPaused = false;
+		}
+		this.isPlaying = false;
+		this.isPaused = false;
+		this.isResuming = false;
+		this.sessionStartTime = 0;
+		this.scheduledTime = 0;
+		for (const source of this.activeSources) {
+			source.onended = null;
+			try {
+				source.stop(0);
+			} catch {}
+			try {
+				source.disconnect();
+			} catch {}
+		}
+		this.activeSources.clear();
+		this.audioChunks = [];
+		this.scheduledChunks = 0;
+		this.autoContinue = false;
+		this.log("[StreamingAudioPlayer] Playback stopped, state reset");
+	}
+	/**
+	* Enable or disable auto-start (for delayed start scenarios)
+	*/
+	setAutoStart(enabled) {
+		this.autoStartEnabled = enabled;
+		this.log(`Auto-start ${enabled ? "enabled" : "disabled"}`);
+	}
+	/**
+	* Start playback manually (for delayed start scenarios)
+	* This allows starting playback after transition animation completes
+	*/
+	async play() {
+		if (this.isPlaying) return;
+		this.autoStartEnabled = true;
+		try {
+			await this.startPlayback();
+		} catch (err) {
+			logger.error("[StreamingAudioPlayer] Failed to start playback from play():", err);
+		}
+	}
+	/**
+	* Mark playback as ended
+	*/
+	markEnded() {
+		this.log("Playback ended");
+		this.isPlaying = false;
+		this.onEndedCallback?.();
+	}
+	/**
+	* Set ended callback
+	*/
+	onEnded(callback) {
+		this.onEndedCallback = callback;
+	}
+	/**
+	* 设置音频缓冲卡顿回调：缓冲耗尽自动暂停时 stalled=true，有数据自动恢复时 stalled=false。
+	*/
+	onAudioStall(callback) {
+		this.onAudioStallCallback = callback;
+	}
+	/**
+	* Check if playing
+	*/
+	isPlayingNow() {
+		return this.isPlaying && !this.isPaused;
+	}
+	/**
+	* Dispose and cleanup
+	*/
+	dispose() {
+		this.stop();
+		if (this.audioContext && this.stateChangeHandler) {
+			this.audioContext.removeEventListener("statechange", this.stateChangeHandler);
+			this.stateChangeHandler = void 0;
+		}
+		if (this.audioContext) {
+			this.audioContext.close();
+			this.audioContext = null;
+			this.gainNode = null;
+		}
+		this.audioChunks = [];
+		this.scheduledChunks = 0;
+		this.sessionStartTime = 0;
+		this.pausedTimeOffset = 0;
+		this.pausedAt = 0;
+		this.pausedAudioContextTime = 0;
+		this.scheduledTime = 0;
+		this.onEndedCallback = void 0;
+		this.log("StreamingAudioPlayer disposed");
+	}
+	/**
+	* Flush buffered audio
+	* - hard: stops all playing sources and clears all chunks
+	* - soft (default): clears UNSCHEDULED chunks only
+	*/
+	flush(options) {
+		if (options?.hard === true) {
+			this.stop();
+			this.audioChunks = [];
+			this.scheduledChunks = 0;
+			this.sessionStartTime = 0;
+			this.pausedAt = 0;
+			this.scheduledTime = 0;
+			this.log("Flushed (hard)");
+			return;
+		}
+		if (this.scheduledChunks < this.audioChunks.length) this.audioChunks.splice(this.scheduledChunks);
+		this.log("Flushed (soft)", { remainingScheduled: this.scheduledChunks });
+	}
+	/**
+	* Set volume (0.0 - 1.0)
+	* Note: This only controls avatar audio player volume, does not affect system volume
+	* @param volume Volume value, range 0.0 to 1.0 (0.0 is mute, 1.0 is max volume)
+	* @internal
+	*/
+	setVolume(volume) {
+		if (volume < 0 || volume > 1) {
+			logger.warn(`[StreamingAudioPlayer] Volume out of range: ${volume}, clamping to [0, 1]`);
+			volume = Math.max(0, Math.min(1, volume));
+		}
+		this.volume = volume;
+		if (this.gainNode) this.gainNode.gain.value = volume;
+	}
+	/**
+	* Get current volume
+	* @returns Current volume value (0.0 - 1.0)
+	* @internal
+	*/
+	getVolume() {
+		return this.volume;
+	}
+	/**
+	* Debug logging
+	*/
+	log(message, data) {
+		if (this.debug) logger.log(`[StreamingAudioPlayer] ${message}`, data || "");
+	}
+};
+//#endregion
+export { StreamingAudioPlayer };