@webex/ladon-ts 5.4.1 → 5.4.3

package/build/module/lib/generator.d.ts

@@ -1,75 +1,74 @@
 import { PipelineConfig } from './config-types';
-
-declare global {
-    interface ImportMeta {
-        url: string;
-    }
-}
-export type FrameData = Uint8ClampedArray | HTMLVideoElement;
-export interface FacesAndLandmarks {
-    data: Float32Array;
-    dims: readonly number[];
-}
-export interface LadonOutput {
-    data: Float32Array;
-    facesAndLandmarks: FacesAndLandmarks;
-    gesture: Float32Array;
-    motion: number;
-    timestamp: number;
-    warm: boolean;
-}
-export interface MaskGenerator {
-    getLadonOutput(input: Uint8ClampedArray, timestamp: number): Promise<LadonOutput>;
-    load(): Promise<void>;
-    isLoaded(): boolean;
-    postRender(input: Uint8ClampedArray, timestamp: number): Promise<void>;
-    destroy(): void;
-}
-export declare class LocalGenerator implements MaskGenerator {
-    readonly config: PipelineConfig;
-    private lastResult;
-    private lastMask;
-    private maskModel?;
-    private lastMaskGenerationTime;
-    private output?;
-    constructor(config: PipelineConfig);
-    /**
-     * This method preprocesses an input Uint8ClampedArray to a Float32Array
-     * while maintaining memory efficiency by reusing a class-scoped output buffer.
-     * If the model rank is 4 (e.g., newer tiny model), it sets an alpha channel value.
-     *
-     * @param {Uint8ClampedArray} input - The input data to be preprocessed
-     * @param {Float32Array} alpha - The alpha channel data
-     * @returns {Float32Array} - The processed data
-     */
-    private preprocess;
-    getTimeSinceLastGeneration(): number;
-    getLadonOutput(input: Uint8ClampedArray, timestamp: number): Promise<LadonOutput>;
-    load(): Promise<void>;
-    isLoaded(): boolean;
-    postRender(_: Uint8ClampedArray): Promise<void>;
-    destroy(): void;
-}
-export declare class NullGenerator implements MaskGenerator {
-    readonly config: PipelineConfig;
-    private lastMask;
-    constructor(config: PipelineConfig);
-    getLadonOutput(_: Uint8ClampedArray): Promise<LadonOutput>;
-    load(): Promise<void>;
-    isLoaded(): boolean;
-    postRender(_: Uint8ClampedArray): Promise<void>;
-    destroy(): void;
-}
-export declare class WorkerGenerator implements MaskGenerator {
-    readonly config: PipelineConfig;
-    private lastMask;
-    private newMask;
-    private worker?;
-    private lastResult;
-    constructor(config: PipelineConfig);
-    getLadonOutput(_: Uint8ClampedArray): Promise<LadonOutput>;
-    load(): Promise<void>;
-    isLoaded(): boolean;
-    postRender(input: Uint8ClampedArray, timestamp: number): Promise<void>;
-    destroy(): void;
-}
+declare global {
+    interface ImportMeta {
+        url: string;
+    }
+}
+export type FrameData = Uint8ClampedArray | HTMLVideoElement;
+export interface FacesAndLandmarks {
+    data: Float32Array;
+    dims: readonly number[];
+}
+export interface LadonOutput {
+    data: Float32Array;
+    facesAndLandmarks: FacesAndLandmarks;
+    gesture: Float32Array;
+    motion: number;
+    timestamp: number;
+    warm: boolean;
+}
+export interface MaskGenerator {
+    getLadonOutput(input: Uint8ClampedArray, timestamp: number): Promise<LadonOutput>;
+    load(): Promise<void>;
+    isLoaded(): boolean;
+    postRender(input: Uint8ClampedArray, timestamp: number): Promise<void>;
+    destroy(): void;
+}
+export declare class LocalGenerator implements MaskGenerator {
+    readonly config: PipelineConfig;
+    private lastResult;
+    private lastMask;
+    private maskModel?;
+    private lastMaskGenerationTime;
+    private output?;
+    constructor(config: PipelineConfig);
+    /**
+     * This method preprocesses an input Uint8ClampedArray to a Float32Array
+     * while maintaining memory efficiency by reusing a class-scoped output buffer.
+     * If the model rank is 4 (e.g., newer tiny model), it sets an alpha channel value.
+     *
+     * @param {Uint8ClampedArray} input - The input data to be preprocessed
+     * @param {Float32Array} alpha - The alpha channel data
+     * @returns {Float32Array} - The processed data
+     */
+    private preprocess;
+    getTimeSinceLastGeneration(): number;
+    getLadonOutput(input: Uint8ClampedArray, timestamp: number): Promise<LadonOutput>;
+    load(): Promise<void>;
+    isLoaded(): boolean;
+    postRender(_: Uint8ClampedArray): Promise<void>;
+    destroy(): void;
+}
+export declare class NullGenerator implements MaskGenerator {
+    readonly config: PipelineConfig;
+    private lastMask;
+    constructor(config: PipelineConfig);
+    getLadonOutput(_: Uint8ClampedArray): Promise<LadonOutput>;
+    load(): Promise<void>;
+    isLoaded(): boolean;
+    postRender(_: Uint8ClampedArray): Promise<void>;
+    destroy(): void;
+}
+export declare class WorkerGenerator implements MaskGenerator {
+    readonly config: PipelineConfig;
+    private lastMask;
+    private newMask;
+    private worker?;
+    private lastResult;
+    constructor(config: PipelineConfig);
+    getLadonOutput(_: Uint8ClampedArray): Promise<LadonOutput>;
+    load(): Promise<void>;
+    isLoaded(): boolean;
+    postRender(input: Uint8ClampedArray, timestamp: number): Promise<void>;
+    destroy(): void;
+}

package/build/module/lib/pipeline.d.ts

@@ -1,85 +1,84 @@
 import { PipelineConfig } from './config-types';
 import { FacesAndLandmarks } from './generator';
-
-export interface IFrameInferenceResult {
-    facesAndLandmarks: FacesAndLandmarks;
-    gesture: Float32Array;
-    motion: number;
-    skipped: boolean;
-    timestamp: number;
-}
-export interface IPipeline {
-    onFrame(timestamp: number, maskNeeded?: boolean): Promise<IFrameInferenceResult>;
-    isLoaded(): boolean;
-    load(): Promise<void>;
-    destroy(): void;
-}
-export declare class Pipeline implements IPipeline {
-    private inputCanvas;
-    private outputCanvas;
-    readonly config: PipelineConfig;
-    private readonly videoElement?;
-    private generator?;
-    private renderer?;
-    private loaded;
-    private inputCanvasCtx;
-    private lastMaskResult?;
-    private frameQueue;
-    private maskQueue;
-    constructor(inputCanvas: HTMLCanvasElement, outputCanvas: HTMLCanvasElement, config: PipelineConfig, videoElement?: HTMLVideoElement | undefined);
-    /**
-     * Processes a single frame and returns the inference result.
-     *
-     * @param timestamp - The timestamp of the frame.
-     * @param performInference - Flag to perform mask inference.
-     * @returns The result of the frame processing.
-     * @throws If the pipeline (generator or renderer) is not loaded.
-     */
-    onFrame(timestamp: number, performInference?: boolean): Promise<IFrameInferenceResult>;
-    /**
-     * Synchronizes frames and masks to ensure they are rendered together.
-     */
-    private renderSyncedFrameAndMask;
-    /**
-     * Gets the raw image data from the input canvas context.
-     *
-     * @param needFreshImageData - Flag to indicate if fresh image data is needed.
-     *
-     * @returns The raw image data.
-     */
-    private getInputFrameData;
-    /**
-     * Resizes the image data if the model expects a fixed size input.
-     *
-     * @param {Uint8ClampedArray} rawImageData - The raw image data.
-     * @returns {Uint8ClampedArray} - The processed mask image data.
-     */
-    private getMaskImageData;
-    /**
-     * Creates the inference result object.
-     *
-     * @param {number} timestamp - The timestamp of the frame.
-     * @param {boolean} performedInference - Indicates if the inference was performed.
-     * @returns {IFrameInferenceResult} - The result object containing inference details.
-     */
-    private createInferenceResult;
-    /**
-     * Checks if the pipeline is loaded.
-     *
-     * @returns True if the pipeline is loaded, false otherwise.
-     */
-    isLoaded(): boolean;
-    /**
-     * Loads the pipeline components such as the generator and renderer.
-     */
-    load(): Promise<void>;
-    /**
-     * Resets the frame and mask queues.
-     */
-    private resetQueues;
-    reset(): void;
-    /**
-     * Destroys the pipeline and cleans up resources.
-     */
-    destroy(): void;
-}
+export interface IFrameInferenceResult {
+    facesAndLandmarks: FacesAndLandmarks;
+    gesture: Float32Array;
+    motion: number;
+    skipped: boolean;
+    timestamp: number;
+}
+export interface IPipeline {
+    onFrame(timestamp: number, maskNeeded?: boolean): Promise<IFrameInferenceResult>;
+    isLoaded(): boolean;
+    load(): Promise<void>;
+    destroy(): void;
+}
+export declare class Pipeline implements IPipeline {
+    private inputCanvas;
+    private outputCanvas;
+    readonly config: PipelineConfig;
+    private readonly videoElement?;
+    private generator?;
+    private renderer?;
+    private loaded;
+    private inputCanvasCtx;
+    private lastMaskResult?;
+    private frameQueue;
+    private maskQueue;
+    constructor(inputCanvas: HTMLCanvasElement, outputCanvas: HTMLCanvasElement, config: PipelineConfig, videoElement?: HTMLVideoElement | undefined);
+    /**
+     * Processes a single frame and returns the inference result.
+     *
+     * @param timestamp - The timestamp of the frame.
+     * @param performInference - Flag to perform mask inference.
+     * @returns The result of the frame processing.
+     * @throws If the pipeline (generator or renderer) is not loaded.
+     */
+    onFrame(timestamp: number, performInference?: boolean): Promise<IFrameInferenceResult>;
+    /**
+     * Synchronizes frames and masks to ensure they are rendered together.
+     */
+    private renderSyncedFrameAndMask;
+    /**
+     * Gets the raw image data from the input canvas context.
+     *
+     * @param needFreshImageData - Flag to indicate if fresh image data is needed.
+     *
+     * @returns The raw image data.
+     */
+    private getInputFrameData;
+    /**
+     * Resizes the image data if the model expects a fixed size input.
+     *
+     * @param {Uint8ClampedArray} rawImageData - The raw image data.
+     * @returns {Uint8ClampedArray} - The processed mask image data.
+     */
+    private getMaskImageData;
+    /**
+     * Creates the inference result object.
+     *
+     * @param {number} timestamp - The timestamp of the frame.
+     * @param {boolean} performedInference - Indicates if the inference was performed.
+     * @returns {IFrameInferenceResult} - The result object containing inference details.
+     */
+    private createInferenceResult;
+    /**
+     * Checks if the pipeline is loaded.
+     *
+     * @returns True if the pipeline is loaded, false otherwise.
+     */
+    isLoaded(): boolean;
+    /**
+     * Loads the pipeline components such as the generator and renderer.
+     */
+    load(): Promise<void>;
+    /**
+     * Resets the frame and mask queues.
+     */
+    private resetQueues;
+    reset(): void;
+    /**
+     * Destroys the pipeline and cleans up resources.
+     */
+    destroy(): void;
+}

package/build/module/lib/preload.d.ts

@@ -1,9 +1,8 @@
 import { PreloadConfig } from './config-types';
-
-/**
- * Preload the resources using the provided configuration. This function is used to preload the model
- * and the worker before creating the pipeline.
- *
- * @param config - The configuration object.
- */
-export declare const preload: (config: PreloadConfig) => Promise<void>;
+/**
+ * Preload the resources using the provided configuration. This function is used to preload the model
+ * and the worker before creating the pipeline.
+ *
+ * @param config - The configuration object.
+ */
+export declare const preload: (config: PreloadConfig) => Promise<void>;

package/build/module/lib/renderer/blur-renderer.d.ts

@@ -2,21 +2,20 @@ import { PipelineConfig } from '../config-types';
 import { FrameData, LadonOutput } from '../generator';
 import { LadonRenderer } from './ladon-renderer';
 import { WebGLRenderer } from './webgl-renderer';
-
-export declare class BlurRenderer extends WebGLRenderer implements LadonRenderer {
-    output_canvas: HTMLCanvasElement;
-    readonly config: PipelineConfig;
-    private program_1;
-    private program_2;
-    private framebuffer;
-    private transfer_texture;
-    private u_blur;
-    private fragment_shader_common;
-    private fragment_shader_pass_1_src;
-    fragment_shader_pass_2_src: string;
-    constructor(output_canvas: HTMLCanvasElement, config: PipelineConfig);
-    render(input: FrameData, mask?: LadonOutput): Promise<void>;
-    load(): Promise<void>;
-    destroy(): void;
-    private getBlurKernel;
-}
+export declare class BlurRenderer extends WebGLRenderer implements LadonRenderer {
+    output_canvas: HTMLCanvasElement;
+    readonly config: PipelineConfig;
+    private program_1;
+    private program_2;
+    private framebuffer;
+    private transfer_texture;
+    private u_blur;
+    private fragment_shader_common;
+    private fragment_shader_pass_1_src;
+    fragment_shader_pass_2_src: string;
+    constructor(output_canvas: HTMLCanvasElement, config: PipelineConfig);
+    render(input: FrameData, mask?: LadonOutput): Promise<void>;
+    load(): Promise<void>;
+    destroy(): void;
+    private getBlurKernel;
+}

package/build/module/lib/renderer/ladon-renderer.d.ts

@@ -1,7 +1,6 @@
 import { FrameData, LadonOutput } from '../generator';
-
-export interface LadonRenderer {
-    render(input: FrameData, mask?: LadonOutput): Promise<void>;
-    load(): Promise<void>;
-    destroy(): void;
-}
+export interface LadonRenderer {
+    render(input: FrameData, mask?: LadonOutput): Promise<void>;
+    load(): Promise<void>;
+    destroy(): void;
+}

package/build/module/lib/renderer/passthrough-renderer.d.ts

@@ -2,14 +2,13 @@ import { PipelineConfig } from '../config-types';
 import { FrameData } from '../generator';
 import { LadonRenderer } from './ladon-renderer';
 import { WebGLRenderer } from './webgl-renderer';
-
-export declare class PassthroughRenderer extends WebGLRenderer implements LadonRenderer {
-    output_canvas: HTMLCanvasElement;
-    readonly config: PipelineConfig;
-    private program;
-    private fragment_shader;
-    constructor(output_canvas: HTMLCanvasElement, config: PipelineConfig);
-    render(input: FrameData): Promise<void>;
-    load(): Promise<void>;
-    destroy(): void;
-}
+export declare class PassthroughRenderer extends WebGLRenderer implements LadonRenderer {
+    output_canvas: HTMLCanvasElement;
+    readonly config: PipelineConfig;
+    private program;
+    private fragment_shader;
+    constructor(output_canvas: HTMLCanvasElement, config: PipelineConfig);
+    render(input: FrameData): Promise<void>;
+    load(): Promise<void>;
+    destroy(): void;
+}

package/build/module/lib/renderer/replacement-renderer.d.ts

@@ -2,18 +2,17 @@ import { PipelineConfig } from '../config-types';
 import { FrameData, LadonOutput } from '../generator';
 import { LadonRenderer } from './ladon-renderer';
 import { WebGLRenderer } from './webgl-renderer';
-
-export declare class ReplacementRenderer extends WebGLRenderer implements LadonRenderer {
-    output_canvas: HTMLCanvasElement;
-    readonly config: PipelineConfig;
-    private program;
-    private background_canvas_ctx;
-    protected background_texture: WebGLTexture;
-    protected fragment_shader: string;
-    constructor(output_canvas: HTMLCanvasElement, config: PipelineConfig);
-    protected buildFragmentShader(): string;
-    protected setupBackgroundTexture(): void;
-    render(input: FrameData, mask?: LadonOutput): Promise<void>;
-    load(): Promise<void>;
-    destroy(): void;
-}
+export declare class ReplacementRenderer extends WebGLRenderer implements LadonRenderer {
+    output_canvas: HTMLCanvasElement;
+    readonly config: PipelineConfig;
+    private program;
+    private background_canvas_ctx;
+    protected background_texture: WebGLTexture;
+    protected fragment_shader: string;
+    constructor(output_canvas: HTMLCanvasElement, config: PipelineConfig);
+    protected buildFragmentShader(): string;
+    protected setupBackgroundTexture(): void;
+    render(input: FrameData, mask?: LadonOutput): Promise<void>;
+    load(): Promise<void>;
+    destroy(): void;
+}

package/build/module/lib/renderer/webgl-renderer.d.ts

@@ -1,26 +1,25 @@
 import { PipelineConfig } from '../config-types';
 import { FrameData, LadonOutput } from '../generator';
-
-type TextureInitializer = () => void;
-export declare abstract class WebGLRenderer {
-    output_canvas: HTMLCanvasElement;
-    readonly config: PipelineConfig;
-    protected intermediate_canvas?: HTMLCanvasElement;
-    protected output_canvas_2d?: CanvasRenderingContext2D;
-    protected gl: WebGL2RenderingContext;
-    protected image_texture: WebGLTexture;
-    protected mask_texture: WebGLTexture;
-    protected verts: Float32Array;
-    protected vertex_shader_src: string;
-    protected fragment_shader_header: string;
-    protected shared_shader_functions: string;
-    constructor(output_canvas: HTMLCanvasElement, config: PipelineConfig);
-    protected initTexturesAndBuffers(): void;
-    protected createTexture(internalFormat: number, width: number, height: number, initializeTexture?: TextureInitializer): WebGLTexture;
-    protected getUVCalculation(): "vec2 st = vec2(1.0 - gl_FragCoord.x / u_resolution.x, 1.0 - gl_FragCoord.y / u_resolution.y);" | "vec2 st = vec2(gl_FragCoord.x / u_resolution.x, 1.0 - gl_FragCoord.y / u_resolution.y);";
-    protected setSharedUniforms(program: WebGLProgram): void;
-    protected uploadVideoStream(input: FrameData): void;
-    protected uploadMask(mask?: LadonOutput): void;
-    protected postDraw(): void;
-}
-export {};
+type TextureInitializer = () => void;
+export declare abstract class WebGLRenderer {
+    output_canvas: HTMLCanvasElement;
+    readonly config: PipelineConfig;
+    protected intermediate_canvas?: HTMLCanvasElement;
+    protected output_canvas_2d?: CanvasRenderingContext2D;
+    protected gl: WebGL2RenderingContext;
+    protected image_texture: WebGLTexture;
+    protected mask_texture: WebGLTexture;
+    protected verts: Float32Array;
+    protected vertex_shader_src: string;
+    protected fragment_shader_header: string;
+    protected shared_shader_functions: string;
+    constructor(output_canvas: HTMLCanvasElement, config: PipelineConfig);
+    protected initTexturesAndBuffers(): void;
+    protected createTexture(internalFormat: number, width: number, height: number, initializeTexture?: TextureInitializer): WebGLTexture;
+    protected getUVCalculation(): "vec2 st = vec2(1.0 - gl_FragCoord.x / u_resolution.x, 1.0 - gl_FragCoord.y / u_resolution.y);" | "vec2 st = vec2(gl_FragCoord.x / u_resolution.x, 1.0 - gl_FragCoord.y / u_resolution.y);";
+    protected setSharedUniforms(program: WebGLProgram): void;
+    protected uploadVideoStream(input: FrameData): void;
+    protected uploadMask(mask?: LadonOutput): void;
+    protected postDraw(): void;
+}
+export {};

package/build/module/lib/renderer.d.ts

@@ -1,5 +1,5 @@
-export * from './renderer/blur-renderer';
-export * from './renderer/ladon-renderer';
-export * from './renderer/passthrough-renderer';
-export * from './renderer/replacement-renderer';
-export * from './renderer/webgl-renderer';
+export * from './renderer/blur-renderer';
+export * from './renderer/ladon-renderer';
+export * from './renderer/passthrough-renderer';
+export * from './renderer/replacement-renderer';
+export * from './renderer/webgl-renderer';