@vunk/plus 1.10.2 → 1.11.0

package/shared/audioToFrames/src/audio/index.mjs

@@ -1,375 +0,0 @@
-import { w as workerConfig } from '../../../config.mjs';
-import { C as CHUNK_DURATION_SECONDS, a as NUM_SEQUENCE_FRAMES, N as NUM_MEL_BINS } from '../../../constants.mjs';
-
-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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-// src/lib/_AsyncQueueEntry.ts
-var _AsyncQueueEntry = class _AsyncQueueEntry {
-  constructor(queue) {
-    __publicField(this, "promise");
-    __publicField(this, "resolve");
-    __publicField(this, "reject");
-    __publicField(this, "queue");
-    __publicField(this, "signal", null);
-    __publicField(this, "signalListener", null);
-    this.queue = queue;
-    this.promise = new Promise((resolve, reject) => {
-      this.resolve = resolve;
-      this.reject = reject;
-    });
-  }
-  setSignal(signal) {
-    if (signal.aborted) return this;
-    this.signal = signal;
-    this.signalListener = () => {
-      const index = this.queue["promises"].indexOf(this);
-      if (index !== -1) this.queue["promises"].splice(index, 1);
-      this.reject(new Error("Request aborted manually"));
-    };
-    this.signal.addEventListener("abort", this.signalListener);
-    return this;
-  }
-  use() {
-    this.dispose();
-    this.resolve();
-    return this;
-  }
-  abort() {
-    this.dispose();
-    this.reject(new Error("Request aborted manually"));
-    return this;
-  }
-  dispose() {
-    if (this.signal) {
-      this.signal.removeEventListener("abort", this.signalListener);
-      this.signal = null;
-      this.signalListener = null;
-    }
-  }
-};
-__name(_AsyncQueueEntry, "AsyncQueueEntry");
-var AsyncQueueEntry = _AsyncQueueEntry;
-
-// src/lib/AsyncQueue.ts
-var _AsyncQueue = class _AsyncQueue {
-  constructor() {
-    /**
-     * The promises array
-     */
-    __publicField(this, "promises", []);
-  }
-  /**
-   * The amount of entries in the queue, including the head.
-   * @seealso {@link queued} for the queued count.
-   */
-  get remaining() {
-    return this.promises.length;
-  }
-  /**
-   * The amount of queued entries.
-   * @seealso {@link remaining} for the count with the head.
-   */
-  get queued() {
-    return this.remaining === 0 ? 0 : this.remaining - 1;
-  }
-  /**
-   * Waits for last promise and queues a new one
-   * @example
-   * ```typescript
-   * const queue = new AsyncQueue();
-   * async function request(url, options) {
-   *     await queue.wait({ signal: options.signal });
-   *     try {
-   *         const result = await fetch(url, options);
-   *         // Do some operations with 'result'
-   *     } finally {
-   *         // Remove first entry from the queue and resolve for the next entry
-   *         queue.shift();
-   *     }
-   * }
-   *
-   * request(someUrl1, someOptions1); // Will call fetch() immediately
-   * request(someUrl2, someOptions2); // Will call fetch() after the first finished
-   * request(someUrl3, someOptions3); // Will call fetch() after the second finished
-   * ```
-   */
-  wait(options) {
-    const entry = new AsyncQueueEntry(this);
-    if (this.promises.length === 0) {
-      this.promises.push(entry);
-      return Promise.resolve();
-    }
-    this.promises.push(entry);
-    if (options?.signal) entry.setSignal(options.signal);
-    return entry.promise;
-  }
-  /**
-   * Unlocks the head lock and transfers the next lock (if any) to the head.
-   */
-  shift() {
-    if (this.promises.length === 0) return;
-    if (this.promises.length === 1) {
-      this.promises.shift();
-      return;
-    }
-    this.promises.shift();
-    this.promises[0].use();
-  }
-  /**
-   * Aborts all the pending promises.
-   * @note To avoid race conditions, this does **not** unlock the head lock.
-   */
-  abortAll() {
-    if (this.queued === 0) return;
-    for (let i = 1; i < this.promises.length; ++i) {
-      this.promises[i].abort();
-    }
-    this.promises.length = 1;
-  }
-};
-__name(_AsyncQueue, "AsyncQueue");
-var AsyncQueue = _AsyncQueue;
-
-async function createAudioContext() {
-  const AudioContextClass = window.AudioContext || window.webkitAudioContext;
-  if (!AudioContextClass) {
-    throw new Error("\u60A8\u7684\u6D4F\u89C8\u5668\u4E0D\u652F\u6301Web Audio API");
-  }
-  const audioContext = new AudioContextClass();
-  if (audioContext.state === "suspended") {
-    await audioContext.resume();
-  }
-  return audioContext;
-}
-class StreamingFeatureExtractorService {
-  constructor() {
-    this.queue = new AsyncQueue();
-    /** 回调函数集合 */
-    this.callbacks = {};
-    /** 存储每个chunk的处理结果，用于最终合并 */
-    this.chunkResults = [];
-    /** 音频总chunk数 */
-    this.totalChunks = 0;
-    /** 已完成的chunk数 */
-    this.completedChunks = 0;
-    /** 已处理的总帧数累加器 */
-    this.totalFramesProcessed = 0;
-    /** 当前是否有任务在运行 */
-    this.isRunning = false;
-    /** 当前处理的音频缓冲区 */
-    this.audioBuffer = null;
-    /** 音频上下文实例，用于创建AudioBuffer */
-    this.audioContext = null;
-    /** 复用的Worker实例，以提高性能 */
-    this.worker = null;
-  }
-  /**
-   * 创建AudioBuffer的兼容方法，处理Safari的限制。
-   * @param numberOfChannels 声道数
-   * @param length 缓冲区长度
-   * @param sampleRate 采样率
-   * @returns AudioBuffer实例
-   */
-  async createAudioBuffer(numberOfChannels, length, sampleRate) {
-    try {
-      return new AudioBuffer({
-        numberOfChannels,
-        length,
-        sampleRate
-      });
-    } catch {
-      if (!this.audioContext) {
-        const AudioContextClass = window.AudioContext || window.webkitAudioContext;
-        this.audioContext = new AudioContextClass();
-      }
-      return this.audioContext.createBuffer(
-        numberOfChannels,
-        length,
-        sampleRate
-      );
-    }
-  }
-  /**
-   * 使用Worker处理AudioBuffer，提取特征
-   * @param audioBuffer 输入的AudioBuffer
-   * @returns Promise<FeatureExtractionResult>
-   */
-  async processWithWorker(audioBuffer) {
-    if (!this.worker) {
-      throw new Error("Worker not initialized");
-    }
-    return new Promise((resolve, reject) => {
-      const cleanup = () => {
-        if (this.worker) {
-          this.worker.removeEventListener("message", handleMessage);
-          this.worker.removeEventListener("error", handleError);
-        }
-      };
-      function handleMessage(event) {
-        cleanup();
-        if (event.data.status === "success") {
-          resolve(event.data.payload);
-        } else {
-          reject(new Error(event.data.error || "Unknown worker error"));
-        }
-      }
-      function handleError(error) {
-        cleanup();
-        reject(error);
-      }
-      this.worker.addEventListener("message", handleMessage);
-      this.worker.addEventListener("error", handleError);
-      const leftChannel = audioBuffer.getChannelData(0);
-      const rightChannel = audioBuffer.numberOfChannels > 1 ? audioBuffer.getChannelData(1) : void 0;
-      const message = {
-        leftChannel,
-        rightChannel,
-        sampleRate: audioBuffer.sampleRate
-      };
-      const transferList = [leftChannel.buffer, rightChannel?.buffer].filter(Boolean);
-      this.worker.postMessage(message, transferList);
-    });
-  }
-  /**
-   * 启动流式音频特征提取。
-   * @param audioBuffer 输入的音频缓冲区。
-   * @param callbacks 处理过程中的回调函数集合。
-   */
-  async processStreaming(audioBuffer, callbacks) {
-    await this.queue.wait();
-    if (this.isRunning) {
-      throw new Error("\u53E6\u4E00\u4E2A\u97F3\u9891\u6B63\u5728\u5904\u7406\u4E2D\uFF0C\u8BF7\u7A0D\u5019\u3002");
-    }
-    this.isRunning = true;
-    this.audioBuffer = audioBuffer;
-    this.callbacks = callbacks;
-    this.chunkResults = [];
-    this.completedChunks = 0;
-    this.totalFramesProcessed = 0;
-    if (!this.worker) {
-      this.worker = new Worker(
-        /* @vite-ignore */
-        `${workerConfig.path}/feature.worker.js`,
-        { type: "module" }
-      );
-    }
-    const durationSeconds = audioBuffer.duration;
-    this.totalChunks = Math.ceil(durationSeconds / CHUNK_DURATION_SECONDS);
-    try {
-      for (let chunkIndex = 0; chunkIndex < this.totalChunks; chunkIndex++) {
-        if (!this.isRunning)
-          break;
-        await this.processChunk(chunkIndex);
-      }
-      if (this.isRunning) {
-        await this.finalize();
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      this.callbacks.onError?.(errorMessage);
-    } finally {
-      await this.queue.shift();
-      this.cleanup();
-    }
-  }
-  /**
-   * 处理单个音频chunk，提取特征并回调。
-   * @param chunkIndex chunk的索引（从0开始）。
-   */
-  async processChunk(chunkIndex) {
-    if (!this.audioBuffer || !this.worker)
-      return;
-    const startTimeSeconds = chunkIndex * CHUNK_DURATION_SECONDS;
-    const endTimeSeconds = Math.min(
-      (chunkIndex + 1) * CHUNK_DURATION_SECONDS,
-      this.audioBuffer.duration
-    );
-    const startSample = Math.floor(
-      startTimeSeconds * this.audioBuffer.sampleRate
-    );
-    const endSample = Math.floor(endTimeSeconds * this.audioBuffer.sampleRate);
-    const chunkLength = endSample - startSample;
-    const chunkBuffer = await this.createAudioBuffer(
-      this.audioBuffer.numberOfChannels,
-      chunkLength,
-      this.audioBuffer.sampleRate
-    );
-    for (let channel = 0; channel < this.audioBuffer.numberOfChannels; channel++) {
-      const sourceData = this.audioBuffer.getChannelData(channel);
-      const chunkData = chunkBuffer.getChannelData(channel);
-      chunkData.set(sourceData.subarray(startSample, endSample));
-    }
-    const result = await this.processWithWorker(chunkBuffer);
-    const chunkResult = {
-      chunkIndex,
-      features: result.features,
-      dimensions: result.dimensions,
-      startTimeSeconds,
-      endTimeSeconds
-    };
-    this.totalFramesProcessed += chunkResult.dimensions[0];
-    this.chunkResults[chunkIndex] = chunkResult;
-    this.completedChunks++;
-    this.callbacks.onChunkComplete?.(chunkResult);
-    this.callbacks.onProgress?.(this.completedChunks, this.totalChunks);
-    this.chunkResults[chunkIndex] = null;
-  }
-  /**
-   * 所有chunk处理完成后，合并特征并调用onComplete。
-   */
-  async finalize() {
-    if (this.completedChunks === 0) {
-      this.callbacks.onError?.("No chunks were processed.");
-      return;
-    }
-    const totalDimensions = [
-      this.totalFramesProcessed,
-      NUM_SEQUENCE_FRAMES,
-      NUM_MEL_BINS
-    ];
-    this.callbacks.onComplete?.(totalDimensions);
-  }
-  /**
-   * 清理内部状态和资源。
-   */
-  cleanup() {
-    this.isRunning = false;
-    this.audioBuffer = null;
-    if (this.worker) {
-      this.worker.terminate();
-      this.worker = null;
-    }
-    this.chunkResults.forEach((chunk) => {
-      if (chunk && chunk.features) {
-        chunk.features = null;
-      }
-    });
-    this.chunkResults = [];
-    this.callbacks = {};
-    this.completedChunks = 0;
-    this.totalChunks = 0;
-    this.totalFramesProcessed = 0;
-  }
-  /**
-   * 停止当前的流式处理。
-   */
-  stop() {
-    if (this.isRunning) {
-      this.isRunning = false;
-      if (this.worker) {
-        this.worker.terminate();
-        this.worker = null;
-      }
-      this.callbacks = {};
-      this.chunkResults = [];
-      this.totalChunks = 0;
-      this.completedChunks = 0;
-      this.totalFramesProcessed = 0;
-    }
-  }
-}
-
-export { StreamingFeatureExtractorService, createAudioContext };

package/shared/audioToFrames/src/config.d.ts

@@ -1,4 +0,0 @@
-declare const workerConfig: {
-    path: string;
-};
-export { workerConfig, };

package/shared/audioToFrames/src/core/constants.d.ts

@@ -1,17 +0,0 @@
-/**
- * @file 共享常量
- *
- * 存储在多个服务中使用的常量，避免重复定义
- *
- * @author Zhonghan Li
- */
-/** Mel 滤波器组的数量 */
-export declare const NUM_MEL_BINS = 80;
-/** 用于后续处理的序列帧数（每个块包含的帧数） */
-export declare const NUM_SEQUENCE_FRAMES = 4;
-/** 每个chunk的时长（秒） */
-export declare const CHUNK_DURATION_SECONDS = 5;
-/** 上下文窗口中的总块数 */
-export declare const WINDOW_NUM_CHUNKS = 32;
-/** 上下文窗口的单边块数（半径） */
-export declare const WINDOW_NUM_CHUNKS_HALF: number;

package/shared/audioToFrames/src/core/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * @file 核心服务模块导出
- * @author Zhonghan Li
- */
-export * from './constants';
-export * from './utils';

package/shared/audioToFrames/src/core/index.mjs

@@ -1,24 +0,0 @@
-export { C as CHUNK_DURATION_SECONDS, N as NUM_MEL_BINS, a as NUM_SEQUENCE_FRAMES, W as WINDOW_NUM_CHUNKS, b as WINDOW_NUM_CHUNKS_HALF } from '../../../constants.mjs';
-
-function normalizeError(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  return "Unknown error occurred";
-}
-function createErrorHandler(context, _fallbackMessage = "Operation failed") {
-  return function(error) {
-    const errorMessage = normalizeError(error);
-    const fullMessage = `${context}: ${errorMessage}`;
-    console.error(fullMessage);
-    throw new Error(fullMessage);
-  };
-}
-function isNonNull(value) {
-  return value !== null && value !== void 0;
-}
-
-export { createErrorHandler, isNonNull, normalizeError };

package/shared/audioToFrames/src/core/utils.d.ts

@@ -1,26 +0,0 @@
-/**
- * @file 共享工具函数
- *
- * 提供基础错误处理工具函数
- *
- * @author Zhonghan Li
- */
-/**
- * 标准化错误对象
- * @param error 原始错误
- * @returns 标准化的错误消息
- */
-export declare function normalizeError(error: unknown): string;
-/**
- * 创建错误处理包装器
- * @param context 错误上下文
- * @param fallbackMessage 备用错误消息
- * @returns 错误处理函数
- */
-export declare function createErrorHandler(context: string, _fallbackMessage?: string): (error: unknown) => never;
-/**
- * 检查值是否为非空
- * @param value 要检查的值
- * @returns 类型守卫结果
- */
-export declare function isNonNull<T>(value: T | null | undefined): value is T;

package/shared/audioToFrames/src/inference/StreamingInferenceService.d.ts

@@ -1,189 +0,0 @@
-/**
- * @file StreamingInferenceService.ts
- *
- * 流式推理服务模块，支持增量推理模式。
- * 1. 每收到一个chunk的音频特征后，立即开始推理该部分的视频帧，显著降低首帧延迟。
- * 2. 支持推理进度、帧级回调、chunk完成回调、全部完成回调及错误处理。
- *
- * @author Zhonghan Li
- */
-import type { ChunkFeatureResult } from '../audio/StreamingFeatureExtractorService';
-import type { ImageDataResponse } from '../media/DataLoaderService';
-/**
- * Worker initialization message
- */
-export interface StreamingWorkerInitMessage {
-    type: 'init';
-    modelPath: string;
-}
-/**
- * Main thread message types for worker communication
- */
-export interface MainThreadFrameMessage {
-    type: 'frame';
-    payload: {
-        frame: ImageBitmap;
-        frameIndex: number;
-    };
-}
-export interface MainThreadChunkCompleteMessage {
-    type: 'chunk_complete';
-    payload: {
-        chunkIndex: number;
-        timings: Record<string, number>;
-    };
-}
-export interface MainThreadProgressMessage {
-    type: 'progress';
-    payload: {
-        processed: number;
-        total: number;
-    };
-}
-export interface MainThreadAllCompleteMessage {
-    type: 'all_complete';
-    payload: Record<string, number>;
-}
-export interface MainThreadErrorMessage {
-    type: 'error';
-    payload: string;
-}
-export interface MainThreadReadyMessage {
-    type: 'ready';
-}
-export type MainThreadMessage = MainThreadFrameMessage | MainThreadChunkCompleteMessage | MainThreadProgressMessage | MainThreadAllCompleteMessage | MainThreadErrorMessage | MainThreadReadyMessage;
-/**
- * 单个流式推理chunk的数据结构。
- */
-export interface StreamingChunkData {
-    /** chunk索引（从0开始） */
-    chunkIndex: number;
-    /** 音频特征（Float32Array） */
-    audioFeatures: Float32Array;
-    /** 特征维度信息 [帧数, 序列长度, mel频带数] */
-    audioDimensions: number[];
-    /** 该chunk对应的起始帧索引 */
-    startFrame: number;
-    /** 该chunk对应的结束帧索引 */
-    endFrame: number;
-}
-/**
- * 发送给worker的流式推理消息类型。
- */
-export interface StreamingWorkerRunMessage {
-    /** 消息类型，固定为 "streaming_run" */
-    type: 'streaming_run';
-    /** 当前chunk的数据 */
-    chunkData: StreamingChunkData;
-    /** 图像数据集（已在init_streaming中发送，此处占位） */
-    dataset: ImageDataResponse;
-    /** 图像Blob映射（已在init_streaming中发送，此处占位） */
-    zipBlob: Blob;
-    /** 融合掩码（已在init_streaming中发送，此处占位） */
-    blendingMaskBitmap: ImageBitmap;
-    /** 起始图像帧索引 */
-    startImageIndex: number;
-}
-/**
- * 流式推理回调接口定义。
- */
-export interface StreamingInferenceCallbacks {
-    /**
-     * 推理进度回调。
-     * @param processed 已处理帧数
-     * @param total 总帧数
-     */
-    onProgress?: (processed: number, total: number) => void;
-    /**
-     * 单帧推理完成回调。
-     * @param frame 生成的视频帧
-     * @param frameIndex 帧索引
-     */
-    onFrame?: (frame: ImageBitmap, frameIndex: number) => void;
-    /**
-     * 单个chunk推理完成回调。
-     * @param chunkIndex chunk索引
-     * @param timings 该chunk的耗时统计
-     */
-    onChunkComplete?: (chunkIndex: number, timings: Record<string, number>) => void;
-    /**
-     * 所有chunk推理完成回调。
-     * @param totalTimings 总耗时统计
-     */
-    onAllComplete?: (totalTimings: Record<string, number>) => void;
-    /**
-     * 推理错误回调。
-     * @param message 错误信息
-     */
-    onError?: (message: string) => void;
-}
-/**
- * 流式推理服务主类。
- */
-export declare class StreamingInferenceService {
-    /** 后台推理Worker实例 */
-    private worker;
-    /** 推理回调函数集合 */
-    private callbacks;
-    /** Worker是否已初始化 */
-    private isInitialized;
-    /** 待推理的chunk数据映射 */
-    private pendingChunks;
-    /** 已完成推理的chunk索引集合 */
-    private completedChunks;
-    /** 当前累计的总帧数 */
-    private totalFrames;
-    /** 是否处于推理处理中 */
-    private isProcessing;
-    /** 全局chunk索引计数器，确保每个chunk有唯一索引 */
-    private globalChunkIndex;
-    private _def;
-    /**
-     * 构造函数，初始化Worker并注册消息回调。
-     * @param modelPath 模型路径
-     * @param onReady Worker初始化完成回调
-     */
-    constructor(modelPath: string, onReady?: () => void);
-    /**
-     * 判断推理服务是否已准备就绪。
-     * @returns 是否已初始化
-     */
-    isReady(): boolean;
-    when(): Promise<void>;
-    /**
-     * 启动流式推理流程，发送共享数据到worker。
-     * @param sharedData 所有chunk共享的数据（图像、配置等）
-     * @param callbacks 推理过程中的回调函数
-     * @param startImageIndex 起始图像帧索引，默认为0
-     */
-    startStreaming(sharedData: {
-        dataset: ImageDataResponse;
-        zipBlob: Blob;
-        blendingMaskBitmap: ImageBitmap;
-    }, callbacks: StreamingInferenceCallbacks, startImageIndex?: number): Promise<void>;
-    /**
-     * 添加一个chunk进行推理。
-     * @param chunkResult 特征提取完成的chunk
-     */
-    addChunk(chunkResult: ChunkFeatureResult): void;
-    /**
-     * 通知所有chunk都已添加完成，发送总帧数到worker。
-     */
-    finishAddingChunks(): void;
-    /**
-     * 清理内部状态和资源。
-     */
-    private cleanup;
-    /**
-     * 轻度清理，保持连续性，用于音频文件间的清理。
-     */
-    private lightCleanup;
-    /**
-     * 停止推理并清理资源，通知worker停止。
-     */
-    stop(): void;
-    /**
-     * 彻底终止worker并清理所有资源。
-     */
-    terminate(): void;
-}

package/shared/audioToFrames/src/inference/index.d.ts

@@ -1,5 +0,0 @@
-/**
- * @file 推理服务模块导出
- * @author Zhonghan Li
- */
-export * from './StreamingInferenceService';

package/shared/audioToFrames/src/inference/index.mjs

@@ -1,3 +0,0 @@
-export { S as StreamingInferenceService } from '../../../StreamingInferenceService.mjs';
-import '@vunk/shared/promise';
-import '../../../config.mjs';