@xmov/avatar 2.4.0 → 2.5.0-alpha.1

package/dist/utils/fpsTracker.d.ts

@@ -1,27 +0,0 @@
-export interface FPSStats {
-    current: number;
-    average: number;
-    min: number;
-    max: number;
-    droppedFrames: number;
-    totalFrames: number;
-}
-export declare class FPSTracker {
-    private frameTimestamps;
-    private maxSamples;
-    private lastFrameTime;
-    private frameCount;
-    private lastUpdateTime;
-    private currentFPS;
-    private totalFrames;
-    private totalTime;
-    private droppedFrames;
-    private totalRenderedFrames;
-    constructor(maxSamples?: number);
-    tick(rendered?: boolean): void;
-    getStats(): FPSStats;
-    getCurrentFPS(): number;
-    getAverageFPS(): number;
-    reset(): void;
-    getDroppedFrames(): number;
-}

package/dist/utils/index.d.ts

@@ -1,22 +0,0 @@
-export declare function isDEV(): boolean;
-export declare function isSupportMES(): boolean;
-export declare function getStyleStr(styles: Record<string, any>): string;
-export declare function updateCanvasXOffset(canvas: any, offset_PX: any): void;
-export declare function generateFingerprint(): string;
-export declare function getDeviceInfo(): {
-    device_id: string;
-    device_brand: string;
-    device_model: string;
-    os_version: string;
-    browser: string;
-    browser_version: string;
-    browser_ua: string;
-};
-/**
- * 校验scale格式（支持小数）并返回合法值
- * @param {unknown} scale - 待校验的scale值
- * @param {string} tag - 日志标签
- * @returns {number | string} 合法值，非法返回1
- */
-export declare function validateScaleWithDecimal(scale: unknown, tag: string): number | string;
-export declare function isharmony(): boolean;

package/dist/utils/logger.d.ts

@@ -1,9 +0,0 @@
-declare function executeLog(consoleMethod: any, ...args: any[]): void;
-declare function setLoggingEnabled(enabled: any): void;
-declare let isLoggingEnabled: boolean;
-declare namespace sdkLog {
-    function log(...args: any[]): void;
-    function info(...args: any[]): void;
-    function warn(...args: any[]): void;
-    function error(...args: any[]): void;
-}

package/dist/utils/media-recorder-timestamp.d.ts

@@ -1,15 +0,0 @@
-type EpochClock = () => number;
-/** Normalizes browser-specific BlobEvent.timecode units to epoch milliseconds. */
-export declare class MediaRecorderTimestamp {
-    private readonly chunkMs;
-    private readonly startedAt;
-    private readonly now;
-    private timecodeScale;
-    private firstTimecode;
-    private lastTimecode;
-    private lastObservedAt;
-    private lastTimestamp;
-    constructor(chunkMs: number, now?: EpochClock);
-    resolve(timecode: number): number;
-}
-export {};

package/dist/utils/pcmAnalyzer.d.ts

@@ -1,40 +0,0 @@
-/**
- * PCM 音频参数分析工具
- * 用于检测和分析 PCM 音频数据的基本参数
- */
-export interface PCMAudioParams {
-    sampleRate: number;
-    channels: number;
-    bitDepth: number;
-    format: string;
-    encoding: string;
-    bytesPerSample: number;
-    sampleCount?: number;
-    duration?: number;
-}
-/**
- * 分析 PCM 音频数据的基本参数
- * @param pcmData PCM 音频数据（Uint8Array）
- * @param knownSampleRate 已知的采样率（可选，如果不提供则使用默认值 24000）
- * @returns PCM 音频参数
- */
-export declare function analyzePCMParams(pcmData?: Uint8Array, knownSampleRate?: number): PCMAudioParams;
-/**
- * 检测 PCM 数据的可能参数（通过分析数据特征）
- * 注意：这种方法只能提供推测，最准确的参数应该从服务器配置中获取
- * @param pcmData PCM 音频数据
- * @returns 检测到的参数（可能不准确）
- */
-export declare function detectPCMParams(pcmData: Uint8Array): Partial<PCMAudioParams>;
-/**
- * 格式化显示 PCM 参数
- * @param params PCM 音频参数
- * @returns 格式化的字符串
- */
-export declare function formatPCMParams(params: PCMAudioParams): string;
-/**
- * 从音频渲染器获取当前 PCM 配置
- * @param audioRenderer 音频渲染器实例
- * @returns PCM 音频参数
- */
-export declare function getPCMParamsFromRenderer(audioRenderer: any): PCMAudioParams;

package/dist/utils/perfermance.d.ts

@@ -1,15 +0,0 @@
-export declare const performanceConstant: {
-    load_resource: string;
-    ttsa_connect: string;
-    ttsa_ready: string;
-    first_avatar_render: string;
-    first_webgl_render: string;
-    ttsa_body_res: string;
-    start_action_res: string;
-    start_action_render: string;
-    load_video: string;
-    decode_video: string;
-    voice_response_play: string;
-    first_decode_video: string;
-    first_render: string;
-};

package/dist/utils/request.d.ts

@@ -1,20 +0,0 @@
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'HEAD';
-interface RequestOptions {
-    method?: HttpMethod;
-    data?: Record<string, any>;
-    headers?: Record<string, string>;
-}
-export default function request(url: string, options?: RequestOptions): Promise<Response>;
-/**
- * 资源下载请求
- * @returns {Promise<[isError: boolean, data: ArrayBuffer | string]>}
- * */
-export declare function XMLRequest(options: {
-    url: string;
-    cache?: {
-        enable: boolean;
-    };
-    timeout?: number;
-    onProgress: (progress: number, e: ProgressEvent) => void;
-}): Promise<[boolean, ArrayBuffer | string]>;
-export {};

package/dist/utils/requestAnimateFrames.d.ts

@@ -1,31 +0,0 @@
-interface FrameAnimationControllerOptions {
-    defaultSpeed?: number;
-    frameRate?: number;
-    frameCallback?: (frame: number, timeJson: any) => void;
-}
-export default class FrameAnimationController {
-    private startTime;
-    private currentFrame;
-    private speed;
-    private frameCallback;
-    private isPlaying;
-    private animationId;
-    private frameRate;
-    private startTimeFromDate;
-    private currentFrameFromDate;
-    constructor({ defaultSpeed, frameRate, frameCallback, }?: FrameAnimationControllerOptions);
-    get playing(): boolean;
-    play(): void;
-    pause(): void;
-    reset(): void;
-    setSpeed(speed: number): void;
-    gotoFrame(frameNumber: number): void;
-    nextFrame(): void;
-    prevFrame(): void;
-    destroy(): void;
-    private _animate;
-    private _updateFrame;
-    getCurrentFrame(): number;
-    updateStartTime(frame: number): void;
-}
-export {};

package/dist/utils/time.d.ts

@@ -1,9 +0,0 @@
-/**
- * @file 时间处理工具函数
- */
-/**
- * 格式化时间戳字符串为 'YYYY-MM-DD HH:mm:ss' 格式
- * @param timestamp - ISO 格式的时间字符串, e.g., "2025-07-02T15:02:36.391615"
- * @returns 格式化后的时间字符串，如果输入无效则返回 'N/A'
- */
-export declare function formatTimestamp(timestamp: string): string;

package/dist/utils/video-probe-asset.d.ts

@@ -1,28 +0,0 @@
-/**
- * 视频解码能力探测片（H.264 High / level 5.0 / 2160x1920 / 10 帧 / 无音轨）
- *
- * 源视频：
- *   https://public-xmov.oss-cn-hangzhou.aliyuncs.com/avatar_sdk_prod/body_ani/M_MX01_show/look/Suyuan_14748_new/1080x1920_fullbody/idle_youling01_cut_000.mp4
- * 源视频实测参数：h264 / High / level 5.0 / coded 2160x1920 / 24fps / 24 帧 / 无音轨
- * 期望 codec 字符串：avc1.640032
- *
- * 生成命令：
- *   ffmpeg -y -i "<源视频>" -frames:v 10 -an -c:v libx264 \
- *     -profile:v high -level 5.0 -refs 5 -crf 51 -preset veryfast \
- *     -pix_fmt yuv420p -movflags +faststart probe_final.mp4
- *
- * 校验命令（期望输出 h264 / High / 50 / 2160 / 1920 / 10）：
- *   ffprobe -v error -show_entries stream=codec_name,profile,level,coded_width,coded_height,nb_frames \
- *     -of default=noprint_wrappers=1 probe_final.mp4
- *
- * 保真说明：
- * - level 与 refs 强制对齐源视频，使 SPS 可观测字段（profile_idc / level_idc / 分辨率 /
- *   CABAC / weighted_pred / transform_8x8 / 约束标志位）与生产码流逐位一致，codec 字符串同为 avc1.640032
- * - 仅压缩帧数（24→10）与质量（CRF 51），分辨率保持 2160x1920，
- *   以便真实覆盖 Android 硬解在 2160x1920 / level 5.0 下的能力边界
- * - 体积 10436 B，base64 后约 13.6KB
- *
- * 保鲜约定：源视频编码参数一旦变化（如改为 H.265、调整 level、更换编码器特性），
- * 本探测片会静默失真，需重新执行上述生成命令并同步更新本注释与期望 codec 字符串。
- */
-export declare const VIDEO_PROBE_BASE64: string;

package/dist/view/DebugOverlay.d.ts

@@ -1,54 +0,0 @@
-import { type SDKError } from "../types/error";
-import { type ISessionResponse } from "../modules/ResourceManager";
-/**
- * 调试信息浮层（支持复制会话ID + 禁止疯狂刷新DOM）
- */
-export declare class DebugOverlay {
-    private container;
-    private sdkContainer;
-    private sdk;
-    private sessionInfo;
-    private startTime;
-    private updateInterval;
-    private errors;
-    private fps;
-    private frameCount;
-    private lastFpsUpdate;
-    private videoInfo;
-    private audioInfo;
-    private eventInfo;
-    private memoryInfo;
-    private perfMetrics;
-    private currentFrameIndex;
-    private domRefs;
-    constructor(sdk: any, sessionInfo: ISessionResponse);
-    setAudioInfo(info: {
-        sf: number;
-        ef: number;
-        ad: Uint8Array;
-    }): void;
-    setEventData(info: {
-        sf: number;
-        ef: number;
-        event: any[];
-    }): void;
-    addError(error: SDKError): void;
-    show(): void;
-    hide(): void;
-    destroy(): void;
-    setVideoInfo(info: any): void;
-    private updateTextOnly;
-    private setText;
-    private copySessionId;
-    private createOverlay;
-    private formatErrors;
-    private updatePerfMetrics;
-    private formatPerfMetrics;
-    private formatMemory;
-    private trackFPS;
-    private updateMemory;
-    private trackMemory;
-    private getNetworkInfo;
-    private applyStyles;
-    private enableDrag;
-}

package/dist/worker/streaming-video.d.ts

@@ -1 +0,0 @@
-export declare const workerURL: string;

package/src/baseRender/AudioRenderer.ts

@@ -1,328 +0,0 @@
-/**
- * 音频渲染
- * 使用 AudioContext 控制
- */
-
-import ResourceManager from "../modules/ResourceManager";
-import { DataCacheQueue } from "../control/DataCacheQueue";
-// import PCMAudioPlayer from "./Audio";
-import AudioWorklet from "./AudioWorklet";
-import { performanceConstant } from "../utils/perfermance";
-import XmovAvatar from "../index";
-import { AvatarStatus } from "../types";
-import MediaSourceAudioPlayer from "./MSEAudioPlayer";
-import { isSupportMES } from "../utils";
-
-type Option = {
-  sdk: XmovAvatar;
-  dataCacheQueue: DataCacheQueue;
-  resourceManager: ResourceManager;
-};
-
-export default class AudioRender {
-  private TAG = "[AudioRenderer]";
-  private options: Option;
-  isPlaying = false;
-  lastFrameIndex: number = -1;
-  audio: AudioWorklet | null = null;
-  firstFrameIndex: number = -1;
-  resourceManager: ResourceManager;
-  valume: number = 1;
-  speech_id: number = -1; // 当前播放的音频id
-  cacheFirstFrameIndex: number = -1; // 缓存下来的第一个音频的索引
-  cacheAudioData: Uint8Array[] = []; // 缓存下来的音频数据
-  oldSpeechId: number = -1; // 上一个播放的音频id
-  mseCacheAudioData: Array<{ data: ArrayBuffer; frameIndex?: number; speechId?: number }> = [];
-  private mseAudioPlayer: MediaSourceAudioPlayer | null = null;
-  
-  constructor(options: Option) {
-    this.options = options;
-    this.resourceManager = options.resourceManager;
-    if(this.resourceManager.config.raw_audio) {
-      this.audio = new AudioWorklet();
-      this.audio.init();
-    } else {
-      this.mseAudioPlayer = MediaSourceAudioPlayer.getInstance(options.sdk);
-    }
-  }
-  updateAudioData(audioList: any) {
-    if (
-      !this.resourceManager.config.raw_audio ||
-      audioList[0].sid === this.oldSpeechId
-    )
-      return;
-    if (this.firstFrameIndex === -1) {
-      this.firstFrameIndex = audioList[0].sf;
-    }
-    let totalLength = 0;
-    for (const audio of audioList) {
-      totalLength += audio.ad?.length || 0;
-    }
-
-    // 创建合并后的Uint8Array
-    const mergedData = new Uint8Array(totalLength);
-    let offset = 0;
-
-    // 填充合并数据
-    for (const audio of audioList) {
-      if (audio.ad) {
-        mergedData.set(new Uint8Array(audio.ad), offset);
-        offset += audio.ad.length;
-      }
-    }
-    if (this.speech_id === -1) {
-      this.speech_id = audioList[0].sid;
-      this.audio?.receivePCMStream(mergedData);
-    } else {
-      if (this.speech_id !== audioList[0].sid) {
-        // 先缓存下来
-        if (this.cacheFirstFrameIndex === -1) {
-          this.cacheFirstFrameIndex = audioList[0].sf;
-        }
-        this.cacheAudioData.push(mergedData);
-      } else {
-        // 直接播放
-        this.audio?.receivePCMStream(mergedData);
-      }
-    }
-  }
-
-  _updateAudio(audioList: any) {
-    if (!this.mseAudioPlayer || audioList.length === 0) return;
-
-    const firstAudio = audioList[0];
-    
-    // 检查是否是旧的 speech_id
-    if (firstAudio.sid === this.oldSpeechId) {
-      return;
-    }
-
-    // 如果 speech_id 变化，停止当前播放并重置
-    if (this.speech_id !== -1 && firstAudio.sid !== this.speech_id) {
-      (window as any).avatarSDKLogger?.log(
-        this.TAG,
-        `检测到新的 speech_id: ${firstAudio.sid}, 当前 WebM 播放 (旧: ${this.speech_id}), 新: ${firstAudio.sid}, 缓存数据长度: ${this.mseCacheAudioData.length}`
-      );
-      if(this.cacheFirstFrameIndex === -1) {
-        this.cacheFirstFrameIndex = firstAudio.sf;
-      }
-      for(const item of audioList) {
-        this.mseCacheAudioData.push({
-          data: item.ad,
-          frameIndex: item.sf,
-          speechId: item.sid,
-        })
-      }
-    } else {
-      // 记录第一个音频段的帧索引
-      if (this.firstFrameIndex === -1) {
-        this.firstFrameIndex = firstAudio.sf;
-      }
-
-      // 更新 speech_id
-      if (this.speech_id === -1) {
-        this.speech_id = firstAudio.sid;
-      } else if (this.speech_id !== firstAudio.sid) {
-        this.speech_id = firstAudio.sid;
-      }
-
-      // 处理每个音频段
-      for (const audio of audioList) {
-        if (audio.ad) {
-          // 将 Uint8Array 转换为 ArrayBuffer
-          const audioData = audio.ad instanceof ArrayBuffer 
-            ? audio.ad 
-            : audio.ad.buffer.slice(audio.ad.byteOffset, audio.ad.byteOffset + audio.ad.byteLength);
-          
-          this.mseAudioPlayer.addAudioSegment(
-            audioData,
-          );
-        }
-      }
-    }
-  }
-
-  async render(frameIndex: number) {
-    (window as any).avatarSDKLogger.log("当前帧索引:", frameIndex, "音频开始播放帧：", this.firstFrameIndex);
-    if (this.lastFrameIndex === -1) {
-      this.lastFrameIndex = frameIndex;
-    }
-    if (this.options.sdk.getStatus() === AvatarStatus.offline) return;
-    // PCM 流式播放（raw_audio = true）
-    if (
-      frameIndex >= this.firstFrameIndex &&
-      this.firstFrameIndex != -1 &&
-      !this.isPlaying &&
-      this.resourceManager.config.raw_audio
-    ) {
-      (window as any).performanceTracker.markEnd(
-        performanceConstant.start_action_render,
-        "speak"
-      );
-      this.isPlaying = true;
-      this.audio?.start();
-      return;
-    }
-
-    // WebM 流式播放（raw_audio = false）
-    if (!this.resourceManager.config.raw_audio && this.mseAudioPlayer) {
-      // 检查是否应该开始播放（帧对齐）
-      if (
-        this.firstFrameIndex !== -1 &&
-        frameIndex >= this.firstFrameIndex &&
-        !this.mseAudioPlayer.isPlaying &&
-        !this.isPlaying
-      ) {
-        // 优化：确保有足够的数据缓冲再开始播放
-        const stats = this.mseAudioPlayer.getStats();
-        const hasEnoughData = stats.queueLength > 0 || stats.bufferedRanges !== '-';
-        if (hasEnoughData) {
-          try {
-            (window as any).avatarSDKLogger.log("开始播放", frameIndex);
-            this.isPlaying = true;
-            await this.mseAudioPlayer.start();
-            (window as any).performanceTracker.markEnd(
-              performanceConstant.start_action_render,
-              "speak"
-            );
-          } catch (error) {
-            (window as any).avatarSDKLogger.error("[AudioRenderer] WebM 音频播放失败:", {
-              error,
-              frameIndex,
-              firstFrameIndex: this.firstFrameIndex,
-              queueLength: stats.queueLength,
-            });
-          }
-        } else {
-          // 数据不足，等待更多数据
-          (window as any).avatarSDKLogger.debug?.(
-            "[AudioRenderer]",
-            `等待更多 WebM 音频数据 (frameIndex: ${frameIndex}, queueLength: ${stats.queueLength})`
-          );
-        }
-      }
-      return; // WebM 模式下不需要继续处理 PCM 播放逻辑
-    }
-  }
-
-  resume() {
-    if (this.audio && this.resourceManager.config.raw_audio) {
-      this.audio?.resume();
-    } else {
-      // if (this.audioCtx.state === "suspended") {
-      //   this.audioCtx
-      //     .resume()
-      //     .then(() => {
-      //       (window as any).avatarSDKLogger.info("音频上下文恢复成功");
-      //     })
-      //     .catch((error) => {
-      //       (window as any).avatarSDKLogger.error("音频上下文恢复失败:", error);
-      //     });
-      // }
-    }
-  }
-
-  pause() {
-    this.isPlaying = false;
-    this.options.dataCacheQueue._clearAudio(this.speech_id);
-    this.lastFrameIndex = -1;
-    this.firstFrameIndex = -1;
-    this.cacheFirstFrameIndex = -1;
-    this.cacheAudioData = [];
-    this.mseCacheAudioData = [];
-    this.oldSpeechId = -1;
-    // 停止 PCM 播放
-    this.audio?.stop();
-
-    // 停止 WebM 播放
-    this.mseAudioPlayer?.stop(this.addNewAudioSegment.bind(this));
-    this.speech_id = -1;
-  }
-
-  stop(speech_id: number) {
-    // speech_id === -1 表示强制清理（用于 pauseRender / destroy / 断网重连场景），不受 oldSpeechId 限制
-    // 否则如果 oldSpeechId >= speech_id 直接返回，避免重复处理
-    if (speech_id !== -1 && this.oldSpeechId >= speech_id) return;
-
-    this.isPlaying = false;
-    this.options.dataCacheQueue._clearAudio(speech_id);
-    this.firstFrameIndex = -1;
-    // 处理缓存的音频数据
-    (window as any).avatarSDKLogger?.log(
-      this.TAG,
-      `清除缓存数据 (speech_id: ${this.speech_id}, PCM缓存数据长度: ${this.cacheAudioData.length}, WebM缓存数据长度: ${this.mseCacheAudioData.length})`
-    );
-    if (this.resourceManager.config.raw_audio) {
-      // 停止 PCM 播放
-      this.audio?.stop();
-    } else {
-      // 停止 WebM 播放
-      this.mseAudioPlayer?.stop(this.addNewAudioSegment.bind(this));
-    }
-    this.oldSpeechId = speech_id;
-    this.speech_id = -1;
-    if (speech_id === -1) {
-      // 强制清理：清空所有缓存数据，不推入音频流（用于 pauseRender / destroy / 断网重连）
-      this.cacheFirstFrameIndex = -1;
-      this.cacheAudioData = [];
-      this.mseCacheAudioData = [];
-    } else if (this.cacheAudioData.length > 0) {
-      this.firstFrameIndex = this.cacheFirstFrameIndex;
-      this.cacheFirstFrameIndex = -1;
-      // 新的缓存下来的数据，推入音频流
-      for (const data of this.cacheAudioData) {
-        this.audio?.receivePCMStream(data);
-      }
-      this.cacheAudioData = [];
-    }
-  }
-
-  addNewAudioSegment() {
-    if(this.mseCacheAudioData.length > 0) {
-      this.firstFrameIndex = this.cacheFirstFrameIndex;
-      this.cacheFirstFrameIndex = -1;
-      // 新的缓存下来的数据，推入音频流
-      for (const audio of this.mseCacheAudioData) {
-        if (audio.data) {
-          this.mseAudioPlayer?.addAudioSegment(
-            audio.data,
-          );
-        }
-      }
-      this.mseCacheAudioData = [];
-    }
-  }
-
-  setVolume(valume: number) {
-    this.valume = valume;
-    if (this.resourceManager.config.raw_audio) {
-      this.audio?.setVolume(valume);
-    } else {
-      // WebM 模式：使用 MSEAudioPlayer 设置音量
-      this.mseAudioPlayer?.setVolume(valume);
-    }
-  }
-
-  setSpeed(speed: number) {
-    if (this.resourceManager.config.raw_audio) {
-      this.audio?.setSpeed(speed);
-    } else {
-      // WebM 模式：使用 MSEAudioPlayer 设置播放速度
-      this.mseAudioPlayer?.setSpeed(speed);
-    }
-  }
-
-  getAudioPlayer(): AudioWorklet | null {
-    return this.audio;
-  }
-
-  destroy() {
-    this.stop(-1);
-    this.cacheAudioData = [];
-    this.mseCacheAudioData = [];
-    this.audio?.destroy();
-    // 直接调用 destroy()，不需要先 stop()（stop 会重建 MediaSource，浪费资源）
-    this.mseAudioPlayer?.destroy();
-    this.mseAudioPlayer = null;
-  }
-}