@xmov/avatar 2.0.0-alpha.38

package/src/baseRender/MSEAudioPlayer.ts

@@ -0,0 +1,243 @@
+export default class MediaSourceAudioPlayer {
+  private mediaSource: MediaSource | null = null;
+  private audioElement: HTMLAudioElement | null = null;
+  private sourceBuffer: SourceBuffer | null = null;
+  public isInitialized = false;
+  public isPlaying = false;
+  private volume = 1.0;
+  private readonly MIME_TYPE = 'audio/webm;codecs=opus';
+  private queue: Array<{ data: ArrayBuffer }> = [];
+  private isUpdating = false;
+  private currentObjectURL: string | null = null;
+  private isDestroyed = false;
+
+  // 速度同步相关（保留不动）
+  private playbackRate = 1.0;
+  public firstFrameIndex = -1;
+
+  // 单例
+  private static instance: MediaSourceAudioPlayer;
+  public static getInstance(sdk): MediaSourceAudioPlayer {
+    if (!MediaSourceAudioPlayer.instance) {
+      MediaSourceAudioPlayer.instance = new MediaSourceAudioPlayer(sdk);
+    }
+    return MediaSourceAudioPlayer.instance;
+  }
+
+  private constructor(sdk) {
+    this.createAudioElement(sdk);
+    this.createNewMediaSource();
+  }
+
+  /**
+   * 只复用 audio 标签！！！
+   */
+  private createAudioElement(sdk) {
+    if (this.audioElement) return;
+    const el = document.getElementById("xmov-avatar-audio");
+    if (el) {
+      this.audioElement = el as HTMLAudioElement;
+      return;
+    }
+    const audio = document.createElement("audio");
+    audio.id = "xmov-avatar-audio";
+    audio.preload = "auto";
+    audio.style.position = "absolute";
+    audio.style.width = "1px";
+    audio.style.height = "1px";
+    audio.style.opacity = "0";
+    audio.style.pointerEvents = "none";
+    audio.style.zIndex = "-9999";
+    sdk.el.appendChild(audio);
+    this.audioElement = audio;
+  }
+
+  /**
+   * 每次都创建 NEW MediaSource
+   * 不复用！不复用！不复用！
+   */
+  private createNewMediaSource(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        if(!this.audioElement) return;
+        this.mediaSource = new MediaSource();
+        this.currentObjectURL = URL.createObjectURL(this.mediaSource);
+        this.audioElement!.src = this.currentObjectURL;
+
+        this.mediaSource.addEventListener("sourceopen", () => {
+          try {
+            if (!this.mediaSource) return;
+            this.sourceBuffer = this.mediaSource.addSourceBuffer(this.MIME_TYPE);
+            this.sourceBuffer.mode = "sequence";
+
+            this.sourceBuffer.addEventListener("updateend", () => {
+              this.isUpdating = false;
+              this.processQueue();
+            });
+
+            this.isInitialized = true;
+            resolve();
+          } catch (e) {
+            reject(e);
+          }
+        });
+
+        this.mediaSource.addEventListener("sourceclose", () => {
+          this.isInitialized = false;
+        });
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+
+  /**
+   * 销毁当前 MediaSource 所有资源
+   * stop 时调用
+   */
+  private async destroyCurrentMediaSource(callback: () => void) {
+    try {
+      if (this.audioElement) {
+        this.audioElement.pause();
+        this.audioElement.removeAttribute("src");
+        this.audioElement.load();
+      }
+    } catch {}
+
+    try {
+      if (this.currentObjectURL) {
+        URL.revokeObjectURL(this.currentObjectURL);
+        this.currentObjectURL = null;
+      }
+    } catch {}
+
+    this.mediaSource = null;
+    this.sourceBuffer = null;
+    this.isInitialized = false;
+    this.isPlaying = false;
+    this.queue = [];
+    this.isUpdating = false;
+    await this.createNewMediaSource();
+    callback();
+  }
+
+  // ==========================
+  // 核心：stop 清空一切，只留 audio
+  // ==========================
+  public stop(callback: () => void) {
+    this.destroyCurrentMediaSource(callback);
+  }
+
+  // ==========================
+  // 添加数据（自动初始化）
+  // ==========================
+  async addAudioSegment(audioData: ArrayBuffer): Promise<void> {
+    if (this.isDestroyed) return;
+    this.queue.push({ data: audioData });
+    this.processQueue();
+  }
+
+  private processQueue() {
+    if (this.isDestroyed) return;
+    if (!this.sourceBuffer || !this.mediaSource) return;
+    if (this.isUpdating || this.queue.length === 0) return;
+    if (this.sourceBuffer.updating || this.mediaSource.readyState !== "open") return;
+
+    this.isUpdating = true;
+    const item = this.queue.shift()!;
+    try {
+      this.sourceBuffer.appendBuffer(item.data);
+    } catch (e) {
+      this.isUpdating = false;
+    }
+  }
+
+  // ==========================
+  // 播放
+  // ==========================
+  async start(): Promise<void> {
+    if (this.isDestroyed || !this.audioElement || this.isPlaying) return;
+
+    try {
+      this.audioElement.currentTime = 0;
+      this.isPlaying = true;
+      await this.audioElement.play();
+      (window as any).avatarSDKLogger.log("mseAudioPlayer开始播放", this.getStats(), Date.now());
+    } catch {}
+  }
+
+  getStats() {
+    return {
+      isPlaying: this.isPlaying,
+      isInitialized: this.isInitialized,
+      queueLength: this.queue.length,
+      bufferedRanges: this.getBufferedRanges(),
+      mediaSourceReadyState: this.mediaSource?.readyState || 'null',
+    };
+  }
+
+  setSpeed(speed: number) {
+    this.setPlaybackRate(speed);
+  }
+  
+  /**
+   * 获取缓冲范围
+   */
+  private getBufferedRanges(): string {
+    if (this.sourceBuffer && this.sourceBuffer.buffered.length > 0) {
+      const ranges: string[] = [];
+      for (let i = 0; i < this.sourceBuffer.buffered.length; i++) {
+        const start = this.sourceBuffer.buffered.start(i).toFixed(2);
+        const end = this.sourceBuffer.buffered.end(i).toFixed(2);
+        ranges.push(`[${start}-${end}]`);
+      }
+      return ranges.join(", ");
+    }
+    return "-";
+  }
+
+  setVolume(volume: number): void {
+    this.volume = Math.max(0, Math.min(1, volume));
+    if (this.audioElement) this.audioElement.volume = this.volume;
+  }
+
+  setPlaybackRate(rate: number): void {
+    this.playbackRate = Math.max(0.5, Math.min(4.0, rate));
+    if (this.audioElement) this.audioElement.playbackRate = this.playbackRate;
+  }
+
+  destroy() {
+    // 0. 标记已销毁，阻止异步操作继续执行
+    this.isDestroyed = true;
+
+    // 1. 停止播放并清除 audio 元素的 src（解除对 blob URL 的引用）
+    if (this.audioElement) {
+      this.audioElement.pause();
+      this.audioElement.removeAttribute("src");
+      this.audioElement.load();
+    }
+
+    // 2. 释放 blob URL（必须在 audio 元素清除 src 之后）
+    if (this.currentObjectURL) {
+      try { URL.revokeObjectURL(this.currentObjectURL); } catch {}
+      this.currentObjectURL = null;
+    }
+
+    // 3. 移除 audio 元素
+    if (this.audioElement) {
+      this.audioElement.remove();
+      this.audioElement = null;
+    }
+
+    // 4. 重置所有状态
+    this.mediaSource = null;
+    this.sourceBuffer = null;
+    this.isInitialized = false;
+    this.isPlaying = false;
+    this.queue = [];
+    this.isUpdating = false;
+
+    // 5. 重置单例，下次 getInstance() 会重新创建
+    MediaSourceAudioPlayer.instance = null as any;
+  }
+}

package/src/baseRender/UIRenderer.ts

@@ -0,0 +1,195 @@
+/**
+ * UI 控件渲染，所有轨道的元素
+ */
+import { DataCacheQueue } from "../control/DataCacheQueue";
+import DefaultWidgetRenderer from "../modules/TrackRenderer/render-implements";
+import TrackerRenderer from "../modules/TrackRenderer/index";
+import ResourceManager from "../modules/ResourceManager";
+import { performanceConstant } from "../utils/perfermance";
+import XmovAvatar from "../index";
+import { EErrorCode } from "../types/error";
+
+type Option = {
+  sdk: XmovAvatar;
+  dataCacheQueue: DataCacheQueue;
+  resourceManager: ResourceManager;
+  enableClientInterrupt: boolean;
+  onVoiceEnd: (client_speak_id: number | string, speech_id: number) => void;
+  onVoiceStart: (duration: number, client_speak_id: number | string) => void;
+  onWalkStateChange: (state: string) => void;
+  sendSdkPoint: (type: string, data: any, extra?: any) => void;
+  onSpeakStateChange: (state: string, client_speak_id: number | string, speech_id: number) => void;
+};
+export default class UIRenderer {
+  private TAG = "[UIRenderer]";
+  options: Option;
+  trackerRenderer: TrackerRenderer[] = [];
+  root = document.createElement("div");
+  lastFrameIndex: number = -1;
+  onVoiceEnd: (client_speak_id: number | string, speech_id: number) => void;
+  onVoiceStart: (duration: number, client_speak_id: number | string) => void;
+  onWalkStateChange: (state: string) => void;
+  initEventsRendered: boolean = false;  
+  lastSpeechId: number = -1;  
+  interruptSpeechId: number = -1;
+  enableClientInterrupt: boolean = false;
+  onSpeakStateChange: (state: string, client_speak_id: number | string, speech_id: number) => void;
+  constructor(options: Option) {
+    this.options = options;
+    this.root.setAttribute("style", "position:absolute;");
+    this.onVoiceStart = options.onVoiceStart;
+    this.onVoiceEnd = options.onVoiceEnd;
+    this.initEventsRendered = false;  
+    this.onWalkStateChange = options.onWalkStateChange;
+    this.enableClientInterrupt = options.enableClientInterrupt;
+    this.onSpeakStateChange = options.onSpeakStateChange;
+  }
+
+  render(frame: number) {
+    // if(this.options.sdk.getStatus() === AvatarStatus.offline) return;
+    let initEvents: any[] = [];
+    if (this.lastFrameIndex === -1) {
+      const config = this.options.resourceManager.getConfig();
+      if(config.init_events && config.init_events.length > 0){
+        initEvents = config.init_events.map(item => ({...item, speech_id:0}));
+      }
+    }
+    let event: any = null;
+    if (frame - this.lastFrameIndex > 1) {
+      event = this.options.dataCacheQueue._getEventInterval(
+        this.lastFrameIndex,
+        frame
+      );
+    } else {
+      event = this.options.dataCacheQueue._getEvent(frame);
+    }
+    this.lastFrameIndex = frame;
+    // 仅执行一次
+    if(!this.initEventsRendered){
+      this.initEventsRendered = true;
+      if(event){
+        event.e = event.e.concat(initEvents);
+      } else {
+        event = {
+          e: initEvents,
+        };
+      }
+    }
+    if (!event?.e) {
+      return;
+    }
+    (window as any).avatarSDKLogger.log("当前帧", frame, "获取到的事件", JSON.stringify(event));
+    // 过滤出不包含speechId的事件list
+    const noSpeechIdEvents = event.e?.filter(item => item?.speech_id === undefined || item?.speech_id === null);
+    if(noSpeechIdEvents?.length) {
+      const typesStr = noSpeechIdEvents.map(item => item.type).join(',');
+      this.options.sdk.onMessage({
+        code: EErrorCode.EVENT_WITHOUT_SPEECH_ID,
+        message: `Error: 事件中存在不包含speech_id的事件${typesStr}`,
+        e: noSpeechIdEvents
+      })
+    }
+    if(this.enableClientInterrupt) {
+      // 根据interruptSpeechId过滤旧的数据,加入前端interrupt事件后，可能在前端打断后，服务仍下发数据 如果type是以_end结尾的，不过滤
+      event.e = event.e?.filter(item => (item.speech_id > this.interruptSpeechId || item.speech_id === undefined || item.speech_id === null) || item.type.endsWith('_end') || item.type === 'subtitle_off');
+    }
+    // 过滤出当前语音的事件
+    if(this.lastSpeechId !== -1 && this.lastSpeechId) {
+      event.e = event.e?.filter(item => item?.speech_id >= this.lastSpeechId);
+    }
+    
+    // 1. 处理 speak_start
+    if (event.e?.some(item => item.type === "speak_start")) {
+      const speakStart = event.e.find(item => item.type === "speak_start");
+      this.lastSpeechId = speakStart?.speech_id;
+      this.onSpeakStateChange("speak_start", speakStart.client_speak_id, speakStart?.speech_id || 0);
+    }
+    // 2. 处理 walk_start / voice_start / speak_walk_start
+    if (event.e?.some(item => item.type === "walk_start") || event.e?.some(item => item.type === "speak_walk_start")) {
+      this.onWalkStateChange("walk_start");
+    }
+    if(event.e?.some(item => item.type === "voice_start")) {
+      const voiceStart = event.e.find(item => item.type === "voice_start");
+      const duration = (window as any).performanceTracker.markEnd(performanceConstant.voice_response_play, 'speak');
+      this.options.sendSdkPoint('rendering_display', {multi_turn_conversation_id: voiceStart?.multi_turn_conversation_id});
+      this.onVoiceStart(duration, voiceStart?.client_speak_id);
+    }
+    // 3. 处理 walk_end / speak_walk_end / voice_end
+    if (event.e?.some(item => item.type === "walk_end") || event.e?.some(item => item.type === "speak_walk_end")) {
+      this.onWalkStateChange("walk_end");
+    }
+    if (event.e?.some(item => item.type === "voice_end")) {
+      const voiceEnd = event.e.find(item => item.type === "voice_end");
+      this.onVoiceEnd(voiceEnd?.client_speak_id || '', voiceEnd?.speech_id || 0);
+    }
+    // 4. 处理 speak_end / speak_error
+    const speakEndEventTypes = ["speak_end", "speak_error"];
+    speakEndEventTypes.forEach(eventType => {
+      const speakEvent = event.e.find(item => item.type === eventType);
+      if (speakEvent) {
+        this.onSpeakStateChange(eventType, speakEvent.client_speak_id, speakEvent?.speech_id || 0);
+      }
+    });
+
+
+    const remainingWidgets = [...event.e];
+
+    // 循环遍历 event.e 数组中的所有元素
+    for (let i = 0; i < event.e.length; i++) {
+      const widgetData = event.e[i];
+      if (Object.prototype.hasOwnProperty.call(widgetData, "event_type")) {
+        // 先不处理 ka/ka_intent
+        continue;
+      }
+      // 如果有自定义的渲染器，则所有事件都交给自定义的渲染器处理
+      if (DefaultWidgetRenderer.CUSTOM_WIDGET) {
+        DefaultWidgetRenderer.CUSTOM_WIDGET(widgetData);
+        // 从剩余元素中删除已处理的元素
+        const index = remainingWidgets.indexOf(widgetData);
+        if (index > -1) {
+          remainingWidgets.splice(index, 1);
+        }
+        continue;
+      }
+      // 如果有代理的渲染器，则根据类型执行代理的渲染器
+      if (DefaultWidgetRenderer.PROXY_WIDGET && DefaultWidgetRenderer.PROXY_WIDGET[widgetData.type]) {
+        DefaultWidgetRenderer.PROXY_WIDGET[widgetData.type](widgetData);
+        
+        // 从剩余元素中删除已处理的元素
+        const index = remainingWidgets.indexOf(widgetData);
+        if (index > -1) {
+          remainingWidgets.splice(index, 1);
+        }
+        continue;
+      }
+    }
+    // 对剩余未自定义的元素执行 TrackerRenderer
+    if (remainingWidgets.length > 0) {
+      // 遍历剩余的元素，每个单独执行 TrackerRenderer
+      // 传递 SDK 实例引用，用于区分不同数字人实例的 widget
+      for (const widgetData of remainingWidgets) {
+        const tracker = new TrackerRenderer(widgetData, this.options.sdk);
+        this.trackerRenderer.push(tracker);
+      }
+    }
+    return this.trackerRenderer;
+  }
+
+  clearTrackerRenderer() {
+    this.trackerRenderer = [];
+  }
+
+  setInterrupt(speech_id: number) {
+    this.interruptSpeechId = speech_id;
+  }
+
+  destroy() {
+    this.lastSpeechId = -1;
+    this.interruptSpeechId = -1;
+    this.lastFrameIndex = -1;
+    this.initEventsRendered = false;
+    // 传递 SDK 实例引用，只清除当前实例的 widget
+    DefaultWidgetRenderer.destroy(this.options.sdk);
+    this.trackerRenderer.forEach((tracker) => tracker.destroy());
+  }
+}

package/src/baseRender/pcm-audio-processor.js

@@ -0,0 +1,267 @@
+// pcm-audio-processor.js - 运行在音频线程的Worklet处理器
+class PCMAudioProcessor extends AudioWorkletProcessor {
+  // 音量配置（与主线程保持一致）
+  static get parameterDescriptors() {
+    return [
+      {
+        name: 'volume',
+        defaultValue: 1.0,
+        minValue: 0.0,
+        maxValue: 1.0,
+        automationRate: 'a-rate' // 支持音频速率自动化
+      }
+    ];
+  }
+
+  constructor() {
+    super();
+    this.config = {
+      sampleRate: 24000, // 固定24kHz采样率
+      bytesPerSample: 2, // S16LE=2字节/采样点
+    };
+    this.pcmCache = new Uint8Array(0); // Worklet内的PCM缓存
+    this.isActive = false; // 播放音频状态（控制是否生成声音）
+    this.isDestroyed = false;
+    this.fadeState = {
+      // 淡入淡出状态（避免片段切换爆音）
+      phase: 'idle', // idle/fadeIn/fadeOut/steady
+      currentGain: 0,
+      fadeTime: 0.01, // 淡入淡出时间（秒，建议最小0.01s避免爆音）
+      fadeSamples: Math.floor(0.01 * 24000), // 淡入淡出样本数（24000Hz下为240样本）
+    };
+    this.currentSegment = null; // 当前处理的音频段（float32数组）
+    this.segmentOffset = 0; // 当前音频段的播放偏移量
+    
+    // 监听主线程消息（接收PCM数据、状态控制等）
+    this.port.onmessage = (e) => this.handleMainThreadMessage(e.data);
+    
+    // 初始化淡入淡出样本数
+    this.fadeState.fadeSamples = Math.floor(this.fadeState.fadeTime * this.config.sampleRate);
+  }
+
+  /**
+   * 处理主线程发来的消息（PCM数据/状态控制等）
+   * @param {Object} data - 消息数据
+   * @param {string} data.type - 消息类型：'pcm'/'start'/'pause'/'stop'/'config'/'destroy'/'volume'
+   * @param {Uint8Array} [data.pcmData] - PCM数据（仅type='pcm'时存在）
+   * @param {Object} [data.config] - 配置更新（仅type='config'时存在）
+   * @param {number} [data.volume] - 音量值（仅type='volume'时存在）
+   */
+  handleMainThreadMessage(data) {
+    switch (data.type) {
+      // 接收主线程下发的PCM流数据
+      case 'pcm':
+        if (data.pcmData instanceof Uint8Array && data.pcmData.length > 0) {
+          // 确保PCM数据字节数为2的整数倍（S16LE要求）
+          const validLength = data.pcmData.length - (data.pcmData.length % this.config.bytesPerSample);
+          if (validLength <= 0) break;
+          
+          // 合并到Worklet缓存
+          const newCache = new Uint8Array(this.pcmCache.length + validLength);
+          newCache.set(this.pcmCache, 0);
+          newCache.set(data.pcmData.subarray(0, validLength), this.pcmCache.length);
+          this.pcmCache = newCache;
+          
+          // 向主线程发送缓存状态
+          this.port.postMessage({
+            type: 'cacheStatus',
+            size: this.pcmCache.length,
+            sampleCount: this.pcmCache.length / this.config.bytesPerSample
+          });
+        }
+        break;
+
+      // 启动播放（继续音频生成）
+      case 'start':
+        this.isActive = true;
+        break;
+
+      // 暂停播放（停止音频生成，保留缓存）
+      case 'pause':
+        this.isActive = false;
+        this.resetSegmentState();
+        break;
+
+      // 停止播放（清空缓存+重置状态）
+      case 'stop':
+        this.isActive = false;
+        this.pcmCache = new Uint8Array(0);
+        this.resetSegmentState();
+        break;
+
+      // 更新配置（如采样率/淡入淡出时间）
+      case 'config':
+        if (data.config.sampleRate) {
+          this.config.sampleRate = data.config.sampleRate;
+          // 重新计算淡入淡出样本数
+          this.fadeState.fadeSamples = Math.floor(this.fadeState.fadeTime * this.config.sampleRate);
+        }
+        if (data.config.fadeTime) {
+          this.fadeState.fadeTime = data.config.fadeTime;
+          this.fadeState.fadeSamples = Math.floor(this.fadeState.fadeTime * this.config.sampleRate);
+        }
+        break;
+
+      // 单独更新音量（可选，也可通过参数自动化控制）
+      case 'volume':
+        this.volume = Number(data.volume);
+        // 通知主线程同步AudioWorkletNode的parameters
+        this.port.postMessage({
+          type: 'syncVolume',
+          volume: this.volume
+        });
+        break;
+
+      // 销毁处理器
+      case 'destroy':
+        this.isDestroyed = true;
+        this.isActive = false;
+        this.pcmCache = new Uint8Array(0);
+        this.resetSegmentState();
+        this.port.postMessage({ type: 'destroyConfirmed' });
+        break;
+  
+      default:
+    }
+  }
+
+  /**
+   * 重置当前音频段状态（暂停/停止时调用）
+   */
+  resetSegmentState() {
+    this.currentSegment = null;
+    this.segmentOffset = 0;
+    this.fadeState.phase = 'idle';
+    this.fadeState.currentGain = 0;
+  }
+
+  /**
+   * S16LE Uint8Array 转 Float32Array（-1~1范围）
+   * @param {Uint8Array} pcmData - PCM数据
+   * @returns {Float32Array} 转换后的音频样本
+   */
+  pcmToFloat32(pcmData) {
+    const sampleCount = pcmData.length / this.config.bytesPerSample;
+    const floatData = new Float32Array(sampleCount);
+    const dataView = new DataView(pcmData.buffer);
+
+    for (let i = 0; i < sampleCount; i++) {
+      // S16LE格式：小端序解析，范围-32768~32767 归一化到-1~1
+      floatData[i] = dataView.getInt16(i * this.config.bytesPerSample, true) / 32768;
+    }
+    return floatData;
+  }
+
+  /**
+   * 计算当前样本的增益（淡入淡出）
+   * @param {number} segmentLength - 当前音频段的总样本数
+   * @returns {number} 增益值（0~1）
+   */
+  calculateGain(segmentLength) {
+    const { phase, fadeSamples } = this.fadeState;
+    const { segmentOffset } = this;
+
+    // 边界保护：防止无效值导致的NaN
+    if (typeof segmentOffset !== 'number' || typeof segmentLength !== 'number' || segmentLength <= 0) {
+      return 0;
+    }
+
+    switch (phase) {
+      // 淡入阶段：从0线性增加到1
+      case 'fadeIn':
+        if (segmentOffset >= fadeSamples) {
+          this.fadeState.phase = 'steady';
+          return 1;
+        }
+        return segmentOffset / fadeSamples;
+
+      // 稳定阶段：增益保持1
+      case 'steady':
+        // 检测是否进入淡出阶段（接近段尾）
+        if (segmentOffset >= segmentLength - fadeSamples) {
+          this.fadeState.phase = 'fadeOut';
+        }
+        return 1;
+
+      // 淡出阶段：从1线性降低到0.0001（避免分音）
+      case 'fadeOut':
+        const fadeStart = Math.max(segmentLength - fadeSamples, 0);
+        const fadeProgress = (segmentOffset - fadeStart) / fadeSamples;
+        return Math.max(1 - fadeProgress, 0.0001);
+
+      // 空闲阶段：增益0
+      case 'idle':
+      default:
+        return 0;
+    }
+  }
+
+  /**
+   * AudioWorklet核心方法：实时生成音频样本（音频线程调用）
+   * @param {Float32Array[][]} inputs - 输入样本
+   * @param {Float32Array[][]} outputs - 输出样本（单声道）
+   * @param {Object} parameters - 音频参数
+   * @returns {boolean} 是否继续运行
+   */
+  process(inputs, outputs, parameters) {
+    // 销毁状态：终止处理
+    if (this.isDestroyed) {
+      if (outputs.length > 0 && outputs[0].length > 0) {
+        outputs[0][0].fill(0);
+      }
+      return false;
+    }
+
+    // 未激活或无输出：返回静音
+    if (!this.isActive || outputs.length === 0 || outputs[0].length === 0) {
+      outputs[0][0].fill(0);
+      return true;
+    }
+
+    const outputBuffer = outputs[0][0];
+    const bufferLength = outputBuffer.length;
+    // 获取音量参数（支持自动化）
+    const volume = parameters.volume.length > 1 
+      ? parameters.volume // 自动化模式：每个样本点可能有不同值
+      : parameters.volume[0]; // 控制模式：整个缓冲区使用相同值
+
+    // 生成输出样本
+    for (let i = 0; i < bufferLength; i++) {
+      // 如当前无音频段且缓存有数据，创建新段
+      if (!this.currentSegment && this.pcmCache.length > 0) {
+        // 使用缓存中的所有数据创建新段
+        this.currentSegment = this.pcmToFloat32(this.pcmCache);
+        // 清空缓存（已处理）
+        this.pcmCache = new Uint8Array(0);
+        this.segmentOffset = 0;
+        // 根据前一段状态决定是否淡入
+        this.fadeState.phase = this.fadeState.phase === 'fadeOut' ? 'steady' : 'fadeIn';
+      }
+
+      // 生成当前样本
+      let sample = 0;
+      if (this.currentSegment) {
+        const segmentLength = this.currentSegment.length;
+        // 确保偏移量有效
+        if (this.segmentOffset < segmentLength) {
+          const gain = this.calculateGain(segmentLength);
+          // 应用淡入淡出增益和音量控制
+          sample = this.currentSegment[this.segmentOffset] * gain * volume;
+          this.segmentOffset++;
+        } else {
+          // 当前段处理完毕，重置
+          this.currentSegment = null;
+          this.segmentOffset = 0;
+          this.fadeState.phase = 'idle';
+        }
+      }
+
+      outputBuffer[i] = sample;
+    }
+
+    return true;
+  }
+}
+
+// 注册Worklet处理器
+registerProcessor('pcm-audio-processor', PCMAudioProcessor);