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

package/dist/StreamingAudioPlayer-2bLnaLam.js

@@ -1,656 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { A as APP_CONFIG, l as logger, e as errorToMessage, a as logEvent } from "./index-CPolDcOo.js";
-class StreamingAudioPlayer {
-  // Mark if AudioContext is being resumed, avoid concurrent resume requests
-  constructor(options) {
-    // AudioContext is managed internally
-    __publicField(this, "audioContext", null);
-    __publicField(this, "sampleRate");
-    __publicField(this, "channelCount");
-    __publicField(this, "debug");
-    // Session-level state
-    __publicField(this, "sessionId");
-    __publicField(this, "sessionStartTime", 0);
-    // AudioContext time when session started
-    __publicField(this, "pausedTimeOffset", 0);
-    // Accumulated paused time
-    __publicField(this, "pausedAt", 0);
-    // Time when paused
-    __publicField(this, "pausedAudioContextTime", 0);
-    // audioContext.currentTime when paused (for resume calculation)
-    __publicField(this, "scheduledTime", 0);
-    // Next chunk schedule time in AudioContext time
-    // Playback state
-    __publicField(this, "isPlaying", false);
-    __publicField(this, "isPaused", false);
-    __publicField(this, "autoStartEnabled", true);
-    // Control whether to auto-start when buffer is ready
-    __publicField(this, "autoContinue", false);
-    // Mark if should auto-continue playback (used after auto-pause when end=false and no data)
-    // Audio buffer queue
-    __publicField(this, "audioChunks", []);
-    __publicField(this, "scheduledChunks", 0);
-    // Number of chunks already scheduled
-    __publicField(this, "activeSources", /* @__PURE__ */ new Set());
-    __publicField(this, "lastScheduledChunkEndTime", 0);
-    // End time of last scheduled chunk (relative time)
-    __publicField(this, "lastGetCurrentTimeLog", 0);
-    // Timestamp of last getCurrentTime log (for throttling)
-    // Track start time (absolute time) and duration of each scheduled chunk for accurate current playback time calculation
-    __publicField(this, "scheduledChunkInfo", []);
-    // Volume control
-    __publicField(this, "gainNode", null);
-    __publicField(this, "volume", 1);
-    // Default volume 1.0 (0.0 - 1.0)
-    // Event callbacks
-    __publicField(this, "onEndedCallback");
-    // 音频缓冲卡顿（缓冲耗尽自动暂停 / 有数据自动恢复）通知：true=进入卡顿，false=恢复。
-    __publicField(this, "onAudioStallCallback");
-    // AudioContext state management
-    __publicField(this, "stateChangeHandler");
-    __publicField(this, "isResuming", false);
-    this.sessionId = `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    this.sampleRate = (options == null ? void 0 : options.sampleRate) ?? APP_CONFIG.audio.sampleRate;
-    this.channelCount = (options == null ? void 0 : options.channelCount) ?? 1;
-    this.debug = (options == null ? void 0 : 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) => {
-        const context = event.target;
-        if (context.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) {
-    var _a;
-    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 });
-    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;
-      (_a = this.onAudioStallCallback) == null ? void 0 : _a.call(this, 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) {
-      const errorMessage = "Failed to create AudioBuffer from PCM data";
-      logger.error(errorMessage);
-      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 = () => {
-        var _a;
-        this.activeSources.delete(source);
-        if (this.activeSources.size === 0) {
-          const lastChunk = this.audioChunks[this.scheduledChunks - 1];
-          const sessionEnded = !!(lastChunk == null ? void 0 : lastChunk.isLast);
-          if (!sessionEnded) {
-            this.log("All audio chunks ended but end=false, pausing and setting autoContinue");
-            (_a = this.onAudioStallCallback) == null ? void 0 : _a.call(this, 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 silenceDuration = 0.01;
-      const numSamples2 = Math.floor(this.sampleRate * silenceDuration);
-      const audioBuffer2 = this.audioContext.createBuffer(
-        this.channelCount,
-        numSamples2,
-        this.sampleRate
-      );
-      for (let channel = 0; channel < this.channelCount; channel++) {
-        const channelData = audioBuffer2.getChannelData(channel);
-        channelData.fill(0);
-      }
-      return audioBuffer2;
-    }
-    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++) {
-        const sampleIndex = i * this.channelCount + channel;
-        channelData[i] = int16Array[sampleIndex] / 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() {
-    var _a;
-    return ((_a = this.audioContext) == null ? void 0 : _a.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() {
-    var _a;
-    this.log("Playback ended");
-    this.isPlaying = false;
-    (_a = this.onEndedCallback) == null ? void 0 : _a.call(this);
-  }
-  /**
-   * 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) {
-    const hard = (options == null ? void 0 : options.hard) === true;
-    if (hard) {
-      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 || "");
-    }
-  }
-}
-export {
-  StreamingAudioPlayer
-};