@pexip/media-processor 16.7.0

package/dist/index.d.ts

@@ -0,0 +1,1129 @@
+import * as _tensorflow_tfjs_backend_webgl_dist_webgl_util from '@tensorflow/tfjs-backend-webgl/dist/webgl_util';
+import * as _tensorflow_tfjs_backend_webgl_dist_gpgpu_util from '@tensorflow/tfjs-backend-webgl/dist/gpgpu_util';
+import * as _tensorflow_tfjs_backend_webgl from '@tensorflow/tfjs-backend-webgl';
+import { Tensor3D } from '@tensorflow/tfjs-core';
+import { Options as Options$3 } from '@pexip/bg-blur/selfie_segmentation';
+import { Queue } from '@pexip/utils';
+
+/**
+ * Interface for Point consist of coordinates x and y
+ *
+ * @alpha
+ */
+interface Point {
+    x: number;
+    y: number;
+}
+interface Size {
+    width: number;
+    height: number;
+}
+type Rect = Point & Size;
+interface Frame extends Size {
+    source: Canvas | HTMLVideoElement | HTMLImageElement;
+}
+/**
+ * Unsubscribe the subscription
+ */
+type Unsubscribe$1 = () => void;
+/**
+ * Same as {@link https://developer.mozilla.org/en-US/docs/Web/API/AudioBuffer | AudioBuffer}
+ * Or the return from {@link https://developer.mozilla.org/en-US/docs/Web/API/AnalyserNode/getFloatFrequencyData | AnalyserNode.getFloatFrequencyData()}
+ */
+type AudioBufferFloats = Float32Array;
+/**
+ * Same as the return from {@link https://developer.mozilla.org/en-US/docs/Web/API/AnalyserNode/getByteFrequencyData | AnalyserNode.getByteFrequencyData()}
+ */
+type AudioBufferBytes = Uint8Array;
+/**
+ * Audio samples from each channel, either in float or bytes form
+ *
+ * @example
+ *
+ * ```
+ * |       |            | Sample Frame 1 | Sample Frame 2 | Sample Frame 3 |
+ * | Input | Channel L: | sample 1       | sample 2       | sample 3       |
+ * |       | Channel R: | sample 1       | sample 2       | sample 3       |
+ * ```
+ * We can get 2 `AudioSamples` from "Channel L" and "Channel R" from "Input"
+ */
+type AudioSamples = number[] | AudioBufferFloats | AudioBufferBytes;
+/**
+ * Data structure for the audio statistics while processing
+ */
+interface AudioStats {
+    /**
+     * Indicating the audio is silent when it is set to `true`
+     */
+    silent: boolean;
+    /**
+     * Indicating the audio is mono when it is set to `true`
+     *
+     * `undefined` means cannot-not-tell.
+     */
+    mono?: boolean;
+    /**
+     * Indicating the audio is low volume when it is set to `true`
+     */
+    lowVolume: boolean;
+    /**
+     * Indicating the audio is clipping when it is set to `true`
+     */
+    clipping: boolean;
+    /**
+     * Peak gain value
+     */
+    peak: number;
+    /**
+     * Global rms
+     */
+    rms: number;
+    /**
+     * Maximum running RMS value
+     */
+    maxRms: number;
+    /**
+     * Maximum Clip count
+     */
+    maxClipCount: number;
+    /**
+     * Value of sum squared sample used for RMS calculation
+     */
+    sumSquare: number;
+    /**
+     * Value of sum number of sample used for RMS calculation
+     */
+    sumLength: number;
+}
+/**
+ * Stats options for calculating the audio stats
+ */
+interface StatsOptions {
+    /**
+     * Used for the analysis
+     */
+    samples: AudioSamples;
+    /**
+     * this will be used for accumulation
+     */
+    baseStats?: AudioStats;
+    /**
+     * Threshold for clipping
+     *
+     * @defaultValue
+     * `1.0` as assuming it is float value
+     */
+    clipThreshold?: number;
+    /**
+     * Threshold for silent
+     *
+     * @defaultValue
+     * 1.0 / 32767
+     */
+    silentThreshold?: number;
+}
+/**
+ * Audio Processor Message to post to AudioWorkletProcessor
+ */
+type AudioProcessorRelease = {
+    type: 'release';
+};
+type AudioProcessorEnable = {
+    type: 'enable';
+    value: boolean;
+};
+type AudioProcessorMessageEvent = MessageEvent<AudioProcessorRelease | AudioProcessorEnable>;
+interface SubscribableOptions {
+    updateFrequency?: number;
+}
+interface WorkletMessagePortOptions<T> {
+    messageHandler: (message: T) => void;
+    errorHandler?: (event: Event) => void;
+}
+interface AnalyzerSubscribableOptions extends SubscribableOptions, WorkletMessagePortOptions<Analyzer> {
+}
+/**
+ * Pass the wasm module from `AudioWorkletNode` to `AudioWorkletProcessor` via
+ * `AudioWorkletNodeOptions`
+ *
+ *  - data: The wasm module data
+ *  - sampleRate: The sample rate for the context
+ *  - shouldSendVAD: Should post VADs to main
+ */
+interface WasmProcessorOptions {
+    data: BufferSource;
+    sampleRate: number;
+    shouldSendVAD?: boolean;
+}
+interface WasmWorkletNodeOptions extends AudioWorkletNodeOptions {
+    processorOptions?: WasmProcessorOptions;
+}
+/**
+ * A wrapper for the Denoise wasm module
+ */
+interface Denoise {
+    vad(channel: number): number;
+    free(): void;
+    pipe(inputs: Float32Array[][], outputs: Float32Array[][]): void;
+}
+type NodeConnectionAction = 'connect' | 'disconnect';
+type BaseAudioNode = Pick<AudioNode, NodeConnectionAction>;
+interface Gain extends BaseAudioNode {
+    readonly node: GainNode;
+    mute: boolean;
+}
+interface Analyzer extends BaseAudioNode {
+    readonly node: AnalyserNode;
+    readonly frequencyBinCount: AnalyserNode['frequencyBinCount'];
+    fftSize: AnalyserNode['fftSize'];
+    minDecibels: AnalyserNode['minDecibels'];
+    maxDecibels: AnalyserNode['maxDecibels'];
+    smoothingTimeConstant: AnalyserNode['smoothingTimeConstant'];
+    /**
+     * Copies the current waveform, or time-domain, data into a Uint8Array
+     * (unsigned byte array) passed into it.
+     *
+     * If the array has fewer elements than the `AnalyserNode.fftSize`, excess
+     * elements are dropped.
+     * If it has more elements than needed, excess elements are ignored.
+     *
+     * @param buffer - Use provided buffer instead of creating a new one
+     *
+     * @remarks
+     * The bytes versions are not cheaper than the float version but provided
+     * for convenient: the byte version are computed from the float version,
+     * using simple quantization to 2^8 values
+     * ref. https://padenot.github.io/web-audio-perf/#analysernode
+     */
+    getByteTimeDomainData(buffer: Uint8Array): void;
+    /**
+     * Copies the current frequency data into a Uint8Array (unsigned byte array)
+     * passed into it.
+     *
+     * The frequency data is composed of integers on a scale from 0 to 255.
+     *
+     * @param buffer - Use provided buffer instead of creating a new one
+     *
+     * @remarks
+     * The bytes versions are not cheaper than the float version but provided
+     * for convenient: the byte version are computed from the float version,
+     * using simple quantization to 2^8 values
+     * ref. https://padenot.github.io/web-audio-perf/#analysernode
+     */
+    getByteFrequencyData(buffer: Uint8Array): void;
+    /**
+     * Copies the current waveform, or time-domain, data into Float32Array
+     * passed into it
+     *
+     * @param buffer - Use provided buffer instead of creating a new one
+     *
+     * @remarks
+     * The buffer size should be the same as `AnalyserNode.fftSize`
+     */
+    getFloatTimeDomainData(buffer: Float32Array): void;
+    /**
+     * Copies the current waveform, or time-domain, data into Float32Array
+     * passed into it
+     *
+     * @param buffer - Use provided buffer instead of creating a new one
+     *
+     * @remarks
+     * The buffer size should be the same as `AnalyserNode.frequencyBinCount`
+     */
+    getFloatFrequencyData(buffer: Float32Array): void;
+    /**
+     * Utility function to get the average volume from `getByteFrequencyData`
+     *
+     * @param options - `buffer`, use provided buffer instead of creating a new
+     * one, and `beforeAlter`, will analyze the raw data before any changes to
+     * the audio signal when it is set to `true`
+     *
+     * @remarks
+     * This is a better option when you only need to get the volume in terms of
+     * performance and complexity.
+     */
+    getAverageVolume(buffer: Float32Array): number;
+}
+interface AudioNodeProps<T extends AudioNode, R extends BaseAudioNode> {
+    name: string;
+    node: R | undefined;
+    audioNode: T | undefined;
+    outputs: WeakSet<AudioNodeInit | AudioParam>;
+}
+type AudioNodeParam = BaseAudioNode | AudioParam;
+type Node = AudioNode | AudioParam;
+type Nodes = Node[];
+type ConnectParamBaseType = AudioParam | BaseAudioNode;
+type ConnectInitParamBaseType = AudioParam | AudioNodeInit;
+type ConnectParamType = ConnectParamBaseType | undefined;
+type ConnectInitParamType = ConnectInitParamBaseType | undefined;
+type AudioNodeInputIndex = number | undefined;
+type AudioNodeOutputIndex = number | undefined;
+type ConnectParamBase<T extends ConnectParamType | ConnectInitParamType> = [
+    T,
+    T extends undefined ? undefined : AudioNodeOutputIndex,
+    T extends undefined ? undefined : AudioNodeInputIndex
+] | T;
+type AudioNodeConnectParam = ConnectParamBase<ConnectParamType>;
+type AudioNodeInitConnectParam = ConnectParamBase<ConnectInitParamType>;
+type AudioNodeInitConnection = AudioNodeInitConnectParam[];
+type AudioNodeInitConnections = AudioNodeInitConnection[];
+interface AudioNodeInit<T extends AudioNode = AudioNode, R extends BaseAudioNode = BaseAudioNode> extends Readonly<AudioNodeProps<T, R>> {
+    /**
+     * Internal function to create the actual AudioNode.
+     * Should ONLY be CALLED inside an AudioGraph
+     *
+     * @param context - Audio Context to use
+     * @param prevNode - The input AudioNode for connection
+     *
+     * @internal
+     */
+    create(context: AudioContext, prevNode?: AudioNode): [T, R];
+    /**
+     * Internal function to connect a signal output
+     * Should ONLY be CALLED inside an AudioGraph
+     *
+     * @param param - The init to connect
+     *
+     * @internal
+     */
+    connect(param: AudioNodeInitConnectParam | undefined): void;
+    /**
+     * Internal function to disconnect a signal output
+     * Should ONLY be CALLED inside an AudioGraph
+     *
+     * @param param - The init to disconnect
+     *
+     * @internal
+     */
+    disconnect(param: AudioNodeInitConnectParam | undefined): void;
+    /**
+     * Check if there is a connection to the provided init
+     * @param init - AudioNodeInit
+     */
+    hasConnectedTo(init: AudioNodeInit | AudioParam): boolean;
+    /**
+     * Internal function to release the node init resources
+     * Should ONLY be CALLED inside an AudioGraph
+     *
+     * @internal
+     */
+    release(): void;
+    toJSON?: () => unknown;
+}
+type MediaStreamAudioSourceNodeInit = AudioNodeInit<MediaStreamAudioSourceNode, MediaStreamAudioSourceNode>;
+type MediaElementAudioSourceNodeInit = AudioNodeInit<MediaElementAudioSourceNode, MediaElementAudioSourceNode>;
+type AnalyzerNodeInit = AudioNodeInit<AnalyserNode, Analyzer>;
+type DenoiseWorkletNodeInit = AudioNodeInit<AudioWorkletNode>;
+type GainNodeInit = AudioNodeInit<GainNode, Gain>;
+type MediaStreamAudioDestinationNodeInit = AudioNodeInit<MediaStreamAudioDestinationNode, MediaStreamAudioDestinationNode>;
+type AudioDestinationNodeInit = AudioNodeInit<AudioDestinationNode, AudioDestinationNode>;
+type DelayNodeInit = AudioNodeInit<DelayNode, DelayNode>;
+type ChannelSplitterNodeInit = AudioNodeInit<ChannelSplitterNode, ChannelSplitterNode>;
+interface WorkletModule {
+    moduleURL: string;
+    options?: WorkletOptions;
+}
+interface AudioGraphOptions {
+    context?: AudioContext;
+    contextOptions?: AudioContextOptions;
+}
+type AudioGraphState = AudioContext['state'] | 'closing';
+interface AudioGraph {
+    readonly context: AudioContext;
+    readonly inits: AudioNodeInit[];
+    readonly state: AudioGraphState;
+    connect(sequence: AudioNodeInitConnection): void;
+    disconnect(sequence: AudioNodeInitConnection): void;
+    addWorklet(moduleURL: string, options?: WorkletOptions): Promise<void>;
+    releaseInit(init: AudioNodeInit): void;
+    release(): Promise<void>;
+}
+/**
+ * We need to add the missing type def to work with AudioContextState in Safari
+ * See https://developer.mozilla.org/en-US/docs/Web/API/BaseAudioContext/state#resuming_interrupted_play_states_in_ios_safari
+ *
+ */
+type UniversalAudioContextState = AudioContextState | 'interrupted';
+type Canvas = HTMLCanvasElement | OffscreenCanvas;
+type CanvasContext = CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D;
+/**
+ * Clock interface to get the current time with now method, @see Performance['now']
+ */
+interface Clock {
+    now: Performance['now'];
+}
+/**
+ * Limit the rate of flow in terms of millisecond, and provided Clock
+ */
+interface ThrottleOptions {
+    throttleMs?: number;
+    clock?: Clock;
+}
+type IsVoice<T> = (data: T) => boolean;
+type AsyncCallback = () => Promise<void>;
+type Callback<R, T extends unknown[]> = (...params: T) => R;
+interface Runner<P extends unknown[]> {
+    start(...params: P): Promise<void>;
+    stop(): void;
+    frameRate: number;
+}
+type RunnerCreator<P extends unknown[], R> = (callback: Callback<R, P>, frameRate: number) => Runner<P>;
+interface Transform<I, O> extends Transformer<I, O> {
+    init(): Promise<void>;
+    destroy(): Promise<void>;
+}
+
+/**
+ * A function to create `AudioContext` using constructor or factory function
+ * depends on the browser supports
+ *
+ * @param options - @see {@link AudioContextOptions}
+ *
+ * @internal
+ */
+declare const createAudioContext: (options?: AudioContextOptions) => AudioContext;
+/**
+ * Resume the stream whenever interrupted
+ *
+ * @param audioContext - AudioContext
+ *
+ * @alpha
+ */
+declare function resumeAudioOnInterruption(audioContext: AudioContext): () => void;
+/**
+ * Resume the AudioContext whenever the source track is unmuted
+ *
+ * @param audioContext - The `AudioContext` to resume
+ *
+ * @alpha
+ */
+declare const resumeAudioOnUnmute: (context: AudioContext) => (track: MediaStreamTrack) => Unsubscribe$1;
+/**
+ * Subscribe MessagePort message from an AudioWorkletNode
+ *
+ * @param workletNode - the node to subscribe
+ * @param options - can pass a message handler here to handle the message
+ */
+declare const subscribeWorkletNode: <T>(workletNode: AudioWorkletNode, { messageHandler, errorHandler }?: Partial<WorkletMessagePortOptions<T>>) => () => void;
+/**
+ * Subscribe to a timeout loop to get the data from Analyzer
+ *
+ * @param analyzer - the analyzer to subscribe
+ * @param options - message handler, etc.
+ */
+declare const subscribeTimeoutAnalyzerNode: (analyzer: Analyzer, { messageHandler, updateFrequency }: AnalyzerSubscribableOptions) => () => void;
+/**
+ * Create a MediaStreamAudioSourceNodeInit
+ *
+ * @param mediaStream - Source MediaStream
+ * @param shouldResetEnabled - Whether or not to enable the cloned track
+ */
+declare const createStreamSourceGraphNode: (mediaStream: MediaStream, shouldResetEnabled?: boolean) => AudioNodeInit<MediaStreamAudioSourceNode, MediaStreamAudioSourceNode>;
+/**
+ * Create a MediaStreamAudioSourceNodeInit
+ *
+ * @param mediaStream - Source MediaStream
+ */
+declare const createMediaElementSourceGraphNode: (mediaElement: HTMLMediaElement) => AudioNodeInit<MediaElementAudioSourceNode, MediaElementAudioSourceNode>;
+/**
+ * Create an analyzer node with push-based subscription
+ */
+declare const createAnalyzerSubscribableGraphNode: ({ messageHandler, updateFrequency, ...analyserOptions }: AnalyzerSubscribableOptions & AnalyserOptions) => AudioNodeInit<AnalyserNode, Analyzer>;
+/**
+ * Create a noise suppression node
+ *
+ * @param data - WebAssembly source
+ */
+declare const createDenoiseWorkletGraphNode: (data: BufferSource, messageHandler?: ((vads: number[]) => void) | undefined) => AudioNodeInit<AudioWorkletNode, AudioWorkletNode>;
+/**
+ * Create a GainNodeInit
+ *
+ * @param mute - initial mute state
+ */
+declare const createGainGraphNode: (mute: boolean) => AudioNodeInit<GainNode, Gain>;
+/**
+ * Create an AnalyzerNodeInit
+ *
+ * @param options - @see {@link AnalyserOptions}
+ */
+declare const createAnalyzerGraphNode: (options?: AnalyserOptions) => AudioNodeInit<AnalyserNode, Analyzer>;
+/**
+ * Create a MediaStreamAudioDestinationNodeInit
+ */
+declare const createStreamDestinationGraphNode: (options?: AudioNodeOptions) => AudioNodeInit<MediaStreamAudioDestinationNode, MediaStreamAudioDestinationNode>;
+/**
+ * Create an `AudioDestinationNode`
+ */
+declare const createAudioDestinationGraphNode: () => AudioNodeInit<AudioDestinationNode, AudioDestinationNode>;
+/**
+ * Create a `DelayNode`
+ *
+ * @param options - @see DelayOptions
+ */
+declare const createDelayGraphNode: (options?: DelayOptions) => AudioNodeInit<DelayNode, DelayNode>;
+/**
+ * Create a ChannelSplitterNode
+ *
+ * @param options - @see ChannelSplitterOptions
+ */
+declare const createChannelSplitterGraphNode: (options?: ChannelSplitterOptions) => AudioNodeInit<ChannelSplitterNode, ChannelSplitterNode>;
+/**
+ * Create a ChannelMergerNode
+ *
+ * @param options - @see ChannelMergerOptions
+ */
+declare const createChannelMergerGraphNode: (options?: ChannelMergerOptions) => AudioNodeInit<ChannelMergerNode, ChannelMergerNode>;
+/**
+ * Accepts AudioNodeInitConnections to build the audio graph within a signal audio context
+ *
+ * @param initialConnections - A list of AudioNodeInit to build the graph in a linear fashion
+ * @param options - @see {@link AudioGraphOptions}
+ *
+ * @example
+ *
+ * ```typescript
+ * const source = createStreamSourceGraphNode(stream);
+ * const analyzer = createAnalyzerGraphNode({fftSize});
+ * const audioGraph = createAudioGraph([[source, analyzer]]);
+ * ```
+ */
+declare const createAudioGraph: (initialConnections: AudioNodeInitConnections, options?: AudioGraphOptions) => AudioGraph;
+type AudioGraphProxyHandler = (target: AudioGraph, args: Parameters<AudioGraph['connect']>) => void;
+interface AudioGraphProxyHandlers {
+    connect?: AudioGraphProxyHandler;
+    disconnect?: AudioGraphProxyHandler;
+}
+declare const createAudioGraphProxy: (audioGraph: AudioGraph, handlers: AudioGraphProxyHandlers) => AudioGraph;
+
+declare const loadScript: (path: string, id: string) => Promise<void>;
+type WasmPaths = [string, string | undefined];
+declare const loadWasms: (paths: WasmPaths[]) => Promise<void>;
+declare const loadTfjsCore: (prodMode: boolean) => Promise<unknown>;
+declare const loadTfjsBackendWebGl: () => Promise<{
+    default: typeof _tensorflow_tfjs_backend_webgl;
+    version_webgl: "4.2.0";
+    webgl: {
+        forceHalfFloat: typeof _tensorflow_tfjs_backend_webgl.forceHalfFloat;
+    };
+    forceHalfFloat(): void;
+    MathBackendWebGL: typeof _tensorflow_tfjs_backend_webgl.MathBackendWebGL;
+    setWebGLContext: typeof _tensorflow_tfjs_backend_webgl.setWebGLContext;
+    GPGPUContext: typeof _tensorflow_tfjs_backend_webgl.GPGPUContext;
+    gpgpu_util: typeof _tensorflow_tfjs_backend_webgl_dist_gpgpu_util;
+    webgl_util: typeof _tensorflow_tfjs_backend_webgl_dist_webgl_util;
+}>;
+
+declare const RENDER_EFFECTS: readonly ["none", "blur", "overlay"];
+declare const SEG_MODELS: readonly ["mediapipeSelfie"];
+/**
+ * Interfaces from "tensorflow-models/body-segmentation" interfaces
+ */
+type MaskUnderlyingType = 'canvasimagesource' | 'imagedata' | 'tensor';
+interface Mask {
+    toCanvasImageSource(): Promise<CanvasImageSource>;
+    toImageData(): Promise<ImageData>;
+    toTensor(): Promise<Tensor3D>;
+    getUnderlyingType(): MaskUnderlyingType;
+}
+/**
+ * Interfaces from "tensorflow-models/body-segmentation" interfaces
+ */
+interface Segmentation {
+    maskValueToLabel: (maskValue: number) => string;
+    mask: Mask;
+}
+type Color = {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+type SegmentationModel = (typeof SEG_MODELS)[number];
+type RenderEffects = (typeof RENDER_EFFECTS)[number];
+type ProcessInputType = ImageData | HTMLVideoElement | HTMLImageElement | OffscreenCanvas | HTMLCanvasElement | ImageBitmap;
+type InputFrame = CanvasImageSource | VideoFrame;
+type ImageType = CanvasImageSource | ProcessInputType | VideoFrame;
+/**
+ * A keypoint that contains coordinate information.
+ */
+interface Keypoint {
+    x: number;
+    y: number;
+    z?: number;
+    score?: number;
+    name?: string;
+}
+interface BoundingBox {
+    xMin: number;
+    yMin: number;
+    xMax: number;
+    yMax: number;
+    width: number;
+    height: number;
+}
+interface Face {
+    keypoints: Keypoint[];
+    box: BoundingBox;
+}
+interface ProcessingSize {
+    /**
+     * Processing Width size
+     */
+    width: number;
+    /**
+     * Processing height size
+     */
+    height: number;
+}
+interface RenderParams extends ProcessingSize {
+    /**
+     * Range in between 0 and 1
+     * @defaultValue `0.5`
+     */
+    foregroundThreshold: number;
+    /**
+     * Range in between 0 and 20
+     * @defaultValue `3`
+     */
+    backgroundBlurAmount: number;
+    /**
+     * Range in between 0 and 20
+     * @defaultValue `3`
+     */
+    edgeBlurAmount: number;
+    /**
+     * @defaultValue `false`
+     */
+    flipHorizontal: boolean;
+    /**
+     * @defaultValue `none`
+     */
+    effects: RenderEffects;
+    /**
+     * Background image used for background replacement
+     */
+    backgroundImage: Canvas | undefined;
+}
+interface AsyncAssets {
+    tfjsCoreLoaded: boolean;
+    tfjsBackendLoaded: boolean;
+    glueLoaded: boolean;
+}
+type ProcessStatus = 'created' | 'opened' | 'opening' | 'processing' | 'idle' | 'closed' | 'destroying' | 'destroyed';
+interface Process {
+    status: ProcessStatus;
+    open(): Promise<void>;
+    close(): void;
+    destroy(): Promise<void>;
+}
+interface Segmenter extends Process, ProcessingSize {
+    model: SegmentationModel;
+    process(input: ProcessInputType): Promise<Segmentation[]>;
+}
+interface Detector<T> extends Process {
+    detect(input: ProcessInputType): Promise<T>;
+}
+interface SegmentationParams extends RenderParams {
+    segmenter: Segmenter;
+    loadBackgroundImage(url: string): Promise<void>;
+    backgroundImageUrl?: string;
+}
+type SegmentationTransform = Transform<InputFrame, InputFrame> & SegmentationParams & Omit<Process, 'open'>;
+
+type Track = MediaStreamVideoTrack | MediaStreamVideoTrackGenerator;
+interface Options$2 {
+    signal?: AbortSignal;
+}
+type ProcessVideoTrack = (track: MediaStreamVideoTrack, transformers: Array<Transformer<InputFrame, InputFrame>>, options?: Options$2) => Promise<Track>;
+declare const createVideoTrackProcessor: () => ProcessVideoTrack;
+interface FallbackOptions {
+    width?: number;
+    height?: number;
+    frameRate?: number;
+}
+declare const createVideoTrackProcessorWithFallback: ({ width, height, frameRate, }?: FallbackOptions) => ProcessVideoTrack;
+
+interface VideoProcessor {
+    open(): Promise<void>;
+    /**
+     * Process the video and return a MediaStream
+     */
+    process: (source: MediaStream) => Promise<MediaStream>;
+    /**
+     * Stop the process of video segmentation
+     */
+    close(): void;
+    /**
+     * Destroy the segmentation wasm instance
+     */
+    destroy: () => Promise<void>;
+}
+declare const createVideoProcessor: (transformers: Array<Transform<InputFrame, InputFrame>>, processTrack: ProcessVideoTrack) => VideoProcessor;
+
+type Params = Omit<RenderParams, 'frameRate'>;
+interface Options$1 extends Omit<Params, 'backgroundImage'> {
+    selfManageSegmenter?: boolean;
+    bgImageUrl?: string;
+}
+declare const createTransform: (segmenter: Segmenter, { width, height, foregroundThreshold, backgroundBlurAmount, edgeBlurAmount, flipHorizontal, effects, selfManageSegmenter, bgImageUrl, }?: Partial<Options$1>) => SegmentationTransform;
+
+type Timeouts = Pick<WindowOrWorkerGlobalScope, 'setTimeout' | 'clearTimeout'>;
+type AsyncCallbackLoopOptions = Timeouts & Pick<Performance, 'now'> & {
+    frameRate: number;
+};
+/**
+ * Create an async callback loop to be called recursively with delay based on
+ * the `frameRate`
+ *
+ * @param callback - The callback to be invoked
+ * @param frameRate - The rate to be expected to invoke the `callback`
+ */
+declare const createAsyncCallbackLoop: <P extends unknown[], R extends Promise<unknown>>(callback: Callback<R, P>, frameRate: number, { setTimeout, clearTimeout, now, }?: Partial<AsyncCallbackLoopOptions>) => {
+    start: (...params: P) => Promise<void>;
+    stop: () => void;
+    frameRate: number;
+};
+type Unsubscribe = () => void;
+/**
+ * Subscribe visibilitychange event
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Document/visibilitychange_event}
+ *
+ * @param callback - A callback to be called with `document.hidden` when the event is trigger
+ */
+declare const subscribeVisibilityChangeEvent: (callback: (hidden: boolean) => Promise<void>) => Unsubscribe;
+
+interface FrameCallbackRequestOptions {
+    /**
+     * Subscribe `visibilitychange` event from the DOM
+     * @see {@link subscribeVisibilityChangeEvent}
+     */
+    subscribeVisibilityChange?: typeof subscribeVisibilityChangeEvent;
+}
+/**
+ * Create a callback loop for video frame processing using
+ * `requestVideoFrameCallback` under-the-hood when available otherwise our
+ * fallback implementation based on `setTimeout`.
+ *
+ * @param callback - To be called by the loop
+ * @param frameRate - A fallback frame rate when we are not able to get the rate
+ * from API
+ */
+declare const createFrameCallbackRequest: (callback: Callback<Promise<void>, [ProcessInputType]>, frameRate: number, { subscribeVisibilityChange, }?: FrameCallbackRequestOptions) => {
+    start: (input: ProcessInputType) => Promise<void>;
+    stop: () => void;
+    frameRate: number;
+};
+
+declare const SelfieSegmentationModelTypes: ['general', 'landscape'];
+type SelfieSegmentationModelType = (typeof SelfieSegmentationModelTypes)[number];
+interface Options extends AsyncAssets, Omit<Options$3, 'modelSelection'> {
+    modelType: SelfieSegmentationModelType;
+    processingWidth: number;
+    processingHeight: number;
+    gluePath: string;
+    selfieMode: boolean;
+    prodMode: boolean;
+}
+declare const createSegmenter: (basePath?: string, { modelType, tfjsCoreLoaded, tfjsBackendLoaded, glueLoaded, processingWidth, processingHeight, gluePath, selfieMode, prodMode, }?: Partial<Options>) => Segmenter;
+
+declare const isRenderEffects: (t: unknown) => t is "blur" | "none" | "overlay";
+declare const isSegmentationModel: (t: unknown) => t is "mediapipeSelfie";
+
+declare const PROCESSING_WIDTH = 768;
+declare const PROCESSING_HEIGHT = 432;
+declare const FOREGROUND_THRESHOLD = 0.5;
+declare const BACKGROUND_BLUR_AMOUNT = 3;
+declare const EDGE_BLUR_AMOUNT = 3;
+declare const FLIP_HORIZONTAL = false;
+declare const FRAME_RATE = 20;
+declare enum AbortReason {
+    Close = "close"
+}
+
+/**
+ * Calculate the distance between two Points
+ *
+ * @param p1 - Point 1
+ * @param p2 - Point 2
+ *
+ * @internal
+ */
+declare function calculateDistance(p1: Point, p2: Point): number;
+/**
+ * Spline Interpolation for Bezier Curve
+ *
+ * @param p1 - Starting point
+ * @param p2 - Point between p1 and p3
+ * @param p3 - Ending point
+ * @param t - tension constant
+ *
+ * @remarks
+ * Ref. http://scaledinnovation.com/analytics/splines/aboutSplines.html
+ * Alt. https://www.particleincell.com/2012/bezier-splines/
+ *
+ * @internal
+ */
+declare function getBezierCurveControlPoints({ p1, p2, p3, t, }: {
+    p1: Point;
+    p2: Point;
+    p3: Point;
+    t: number;
+}): [Point, Point];
+/**
+ * Create a straight line path command
+ *
+ * @param data - An array of Points
+ *
+ * @example
+ *
+ * ```typescript
+ * line([{x:0, y:0}, {x:2, y:2}]);
+ * // Output:
+ * // M 0,0 L 2,2
+ * ```
+ *
+ * @alpha
+ */
+declare const line: (data: Point[]) => string;
+/**
+ * Create a cubic Bezier curve path command
+ *
+ * @param data - An array of Points
+ *
+ * @example
+ *
+ * ```typescript
+ * curve([{x:0, y:0}, {x:3, y:4}, {x:9, y:16}]);
+ * // Output:
+ * // M 0,0 C 0,0 1.778263374435667,1.8280237767745193 3,4 C 6.278263374435667,9.828023776774518 9,16 9,16
+ * ```
+ *
+ * @alpha
+ */
+declare const curve: (data: Point[]) => string;
+/**
+ * Create a cubic Bezier curve path then turning back to the starting point with
+ * provided point of reference
+ *
+ * @param reference - reference coordinates, straight to y then x then the starting point
+ * @param data - An array of Points
+ *
+ * @example
+ *
+ * ```typescript
+ * closedCurve({x:0, y:20})([{x:0, y:0}, {x:3, y:4}, {x:9, y:16}]);
+ * // Output:
+ * // M 0,0 C 0,0 1.778263374435667,1.8280237767745193 3,4 C 6.278263374435667,9.828023776774518 9,16 9,16 V 20 H 0 Z
+ * ```
+ *
+ * @alpha
+ */
+declare const closedCurve: ({ x, y }: Point) => (data: Point[]) => string;
+
+/**
+ * Sum an array of numbers
+ *
+ * @param nums - An array of numbers
+ */
+declare const sum: (nums: number[]) => number;
+/**
+ * Average an array of numbers
+ *
+ * @param nums - An array of numbers
+ */
+declare const avg: (nums: number[]) => number;
+/**
+ * pow function from Math in functional form `number -> number -> number`
+ *
+ * @param exponent - The exponent used for the expression
+ * @param base - The base value to be powered
+ *
+ * @returns Math.pow(base, exponent)
+ */
+declare const pow: (exponent: number) => (base: number) => number;
+/**
+ * Calculate the Root Mean Square from provided numbers
+ *
+ * @param nums - An array of numbers
+ */
+declare const rms: (nums: number[]) => number;
+/**
+ * Round the floating point number away from zero, which is different from
+ * `Math.round`
+ *
+ * @param num - The number to round
+ *
+ * @example
+ *
+ * ```typescript
+ * round(0.5) // 1
+ * round(-0.5) // -1
+ * ```
+ */
+declare const round: (num: number) => number;
+
+/**
+ * Default silent threshold
+ * At least one LSB 16-bit data (compare is on absolute value).
+ */
+declare const SILENT_THRESHOLD: number;
+/**
+ * Default mono detection threshold
+ * Data must be identical within one LSB 16-bit to be identified as mono.
+ */
+declare const MONO_THRESHOLD: number;
+/**
+ * Default low volume detection threshold
+ */
+declare const LOW_VOLUME_THRESHOLD = -60;
+/**
+ * Default clipping detection threshold
+ */
+declare const CLIP_THRESHOLD = 0.98;
+/**
+ * Default Voice probability threshold
+ */
+declare const VOICE_PROBABILITY_THRESHOLD = 0.3;
+/**
+ * Default clipping count threshold
+ * Number of consecutive clipThreshold level samples that indicate clipping.
+ */
+declare const CLIP_COUNT_THRESHOLD = 6;
+/**
+ * AudioStats builder
+ *
+ * @param stats - overwrite the default attributes
+ * @param options - `silentThreshold`, `lowVolumeThreshold` and
+ * `clipCountThreshold`
+ */
+declare const createAudioStats: (stats?: Partial<AudioStats>, { silentThreshold, lowVolumeThreshold, clipCountThreshold, }?: {
+    silentThreshold?: number | undefined;
+    lowVolumeThreshold?: number | undefined;
+    clipCountThreshold?: number | undefined;
+}) => AudioStats;
+/**
+ * Convert a byte to float, according to web audio spec
+ *
+ * Floating point audio sample number is defined as: non-interleaved IEEE754
+ * 32-bit linear PCM with a nominal range between -1 and +1, that is, 32bits
+ * floating point buffer, with each samples between -1.0 and 1.0
+ * https://developer.mozilla.org/en-US/docs/Web/API/AudioBuffer
+ *
+ * Byte samples are represented as follows:
+ * 128 is silence, 0 is negative max, 256 is positive max
+ *
+ * @param value - The byte value to convert to float
+ *
+ * @remarks
+ * Ref. https://www.w3.org/TR/webaudio/#dom-analysernode-getbytetimedomaindata
+ */
+declare const fromByteToFloat: (value: number) => number;
+/**
+ * Convert a float to byte, according to web audio spec
+ *
+ * Floating point audio sample number is defined as: non-interleaved IEEE754
+ * 32-bit linear PCM with a nominal range between -1 and +1, that is, 32bits
+ * floating point buffer, with each samples between -1.0 and 1.0
+ * https://developer.mozilla.org/en-US/docs/Web/API/AudioBuffer
+ *
+ * Byte samples are represented as follows:
+ * 128 is silence, 0 is negative max, 256 is positive max
+ *
+ * @param value - The float value to convert to byte
+ *
+ * @remarks
+ * Ref. https://www.w3.org/TR/webaudio/#dom-analysernode-getbytetimedomaindata
+ */
+declare const fromFloatToByte: (value: number) => number;
+/**
+ * Copy data from Uint8Array buffer to Float32Array buffer with byte to float conversion
+ *
+ * @param bytes - The source Byte buffer
+ * @param floats - The destination buffer
+ */
+declare const copyByteBufferToFloatBuffer: (bytes: Uint8Array, floats: Float32Array) => void;
+/**
+ * Convert a floating point gain value into a dB representation without any
+ * reference, dBFS, https://en.wikipedia.org/wiki/DBFS
+ *
+ * See https://www.w3.org/TR/webaudio#conversion-to-db
+ *
+ * @param amplitude - Expected a value in (0, 1]
+ */
+declare const toDecibel: (gain: number) => number;
+/**
+ * Calculate the averaged volume using Root Mean Square, assuming the data is in
+ * float form
+ *
+ * @param data - Audio Frequency data
+ *
+ * @alpha
+ */
+declare const processAverageVolume: (data: number[]) => number;
+/**
+ * Simple silent detection to only check the first and last bit from the sample
+ *
+ * @param samples - Audio sample data, this could be in a form of floating number
+ * of a byte number as long as the `threshold` value is given accordingly.
+ * @param threshold - Silent threshold
+ *
+ * @defaultValue
+ * `1.0 / 32767` assuming the sample is float value
+ *
+ * @returns
+ * `true` when it is silent
+ */
+declare const isSilent: (samples: AudioSamples, threshold?: number) => boolean;
+/**
+ * Check if the provided gain above the low volume threshold, which is
+ * considered as low volume.
+ *
+ * @param gain - Floating point representation of the gain number
+ *
+ * @returns
+ * `true` if the `gain` is lower than the threshold
+ */
+declare const isLowVolume: (gain: number, threshold?: number) => boolean;
+/**
+ * Check if there is clipping
+ *
+ * @param clipCount - Number of consecutive clip
+ *
+ * @returns
+ * `true` if the `clipCount` is above the threshold, aka clipping
+ */
+declare const isClipping: (clipCount: number, threshold?: number) => boolean;
+/**
+ * Check if provided channels are mono or stereo
+ *
+ * @param channels - Audio channels and assuming the inputs are in floating
+ * point form
+ * @param threshold - Mono detection threshold, default to floating point form
+ *
+ * @defaultValue
+ * `1.0 / 32767`
+ *
+ * @returns
+ * `true` if they are mono, otherwise stereo
+ */
+declare const isMono: (channels: AudioSamples[], threshold?: number) => boolean;
+/**
+ * Calculate the audio stats, expected the samples are in float form
+ *
+ * @param options - See StatsOptions
+ *
+ * @remarks
+ * http://www.rossbencina.com/code/real-time-audio-programming-101-time-waits-for-nothing
+ */
+declare const getAudioStats: ({ samples, baseStats, clipThreshold, }: StatsOptions) => AudioStats;
+/**
+ * VAD options
+ */
+interface VAOptions {
+    /**
+     * the RMS threshold used to compare with the input RMS
+     */
+    volumeThreshold?: number;
+    /**
+     * The threshold for a voice pulse in terms of time, in millisecond
+     */
+    VADTimeThreshold?: number;
+    /**
+     * The clock, can be used for testing
+     *
+     * @defaultValue
+     * `performance`
+     */
+    clock?: Clock;
+}
+/**
+ * A Naive Voice activity detection
+ *
+ * @param options - See `VAOptions`
+ *
+ * @returns `(volume: number) => boolean`, `true` if there is voice
+ */
+declare const isVoiceActivity: ({ volumeThreshold, VADTimeThreshold, clock, }?: VAOptions) => (volume: number) => boolean;
+/**
+ * Compare the provided width and height to see if they are the same
+ *
+ * @param widthA - The width of A
+ * @param heightA - The height of A
+ * @param widthB - The width of B
+ * @param heightB - The height of B
+ */
+declare const isEqualSize: (widthA: number, heightA: number, widthB: number, heightB: number) => boolean;
+/**
+ * Convert the source size to destination size when necessary based on the
+ * height
+ *
+ * @param sw - Source width
+ * @param sh - Source height
+ * @param dw - destination width
+ * @param dh - destination height
+ */
+declare const fitDestinationSize: (sw: number, sh: number, dw: number, dh: number) => Rect;
+/**
+ * A function to check provided time series data is considered as voice activity
+ *
+ * @param options - @see VAOptions
+ */
+declare const createVoiceDetectorFromTimeData: (options?: VAOptions) => IsVoice<number[]>;
+/**
+ * A function to check the provided probability is considered as voice activity
+ *
+ * @param voiceThreshold - A threshold of the probability to be considered as
+ * voice activity
+ */
+declare const createVoiceDetectorFromProbability: (voiceThreshold?: number) => IsVoice<number>;
+/**
+ * Create a voice detector based on provided params
+ *
+ * @param onDetected - When there is voice activity, this callback will be called
+ * @param shouldDetect - When return `true`, voice activity will function, otherwise, not function
+ * @param options - @see ThrottleOptions
+ */
+declare const createVADetector: (onDetected: () => void, shouldDetect: () => boolean, options?: ThrottleOptions) => <T>(isVoice: IsVoice<T>) => (data: T) => void;
+/**
+ * Create a function to process the AudioStats and check if silent
+ * `onSignalDetected` callback is called under 2 situations:
+ *
+ * ```
+ * Logic
+ * lastCheck | silent | should call onSignalDetected
+ * 0         | 0      | 0
+ * 0         | 1      | 1
+ * 1         | 0      | 1
+ * 1         | 1      | 0
+ * ```
+ */
+declare const createAudioSignalDetector: (shouldDetect: () => boolean, onDetected: (silent: boolean) => void) => (buffer: Queue<number[]>, threshold?: number) => (samples: number[]) => void;
+
+declare const isAudioNode: (t: unknown) => t is AudioNode;
+declare const isAudioParam: (t: unknown) => t is AudioParam;
+declare const isAudioNodeInit: (t: unknown) => t is AudioNodeInit<AudioNode, BaseAudioNode>;
+declare const isAnalyzerNodeInit: (t: unknown) => t is AnalyzerNodeInit;
+
+interface Benchmark {
+    begin(): void;
+    end(): void;
+    calculateFps(): number;
+}
+interface BenchmarkOptions {
+    calculationThresholdMS?: number;
+}
+declare const createBenchmark: (clock?: Clock, { calculationThresholdMS }?: BenchmarkOptions) => Benchmark;
+declare const calculateFps: (time: number) => number;
+
+/**
+ * A library for media analysis using Web APIs.
+ *
+ * @packageDocumentation
+ */
+
+declare const urls: {
+    denoise: () => URL;
+};
+
+export { AbortReason, Analyzer, AnalyzerNodeInit, AnalyzerSubscribableOptions, AsyncAssets, AsyncCallback, AudioBufferBytes, AudioBufferFloats, AudioDestinationNodeInit, AudioGraph, AudioGraphOptions, AudioNodeConnectParam, AudioNodeInit, AudioNodeInitConnectParam, AudioNodeInitConnection, AudioNodeInitConnections, AudioNodeParam, AudioNodeProps, AudioProcessorEnable, AudioProcessorMessageEvent, AudioProcessorRelease, AudioSamples, AudioStats, BACKGROUND_BLUR_AMOUNT, BaseAudioNode, Benchmark, BoundingBox, CLIP_COUNT_THRESHOLD, CLIP_THRESHOLD, Callback, Canvas, CanvasContext, ChannelSplitterNodeInit, Clock, Color, ConnectInitParamBaseType, ConnectInitParamType, ConnectParamBase, ConnectParamBaseType, ConnectParamType, DelayNodeInit, Denoise, DenoiseWorkletNodeInit, Detector, EDGE_BLUR_AMOUNT, FLIP_HORIZONTAL, FOREGROUND_THRESHOLD, FRAME_RATE, Face, Frame, Gain, GainNodeInit, ImageType, InputFrame, IsVoice, Keypoint, LOW_VOLUME_THRESHOLD, MONO_THRESHOLD, Mask, MaskUnderlyingType, MediaElementAudioSourceNodeInit, MediaStreamAudioDestinationNodeInit, MediaStreamAudioSourceNodeInit, Node, NodeConnectionAction, Nodes, PROCESSING_HEIGHT, PROCESSING_WIDTH, Point, Process, ProcessInputType, ProcessStatus, ProcessVideoTrack, RENDER_EFFECTS, Rect, RenderEffects, RenderParams, Runner, RunnerCreator, SEG_MODELS, SILENT_THRESHOLD, Segmentation, SegmentationModel, SegmentationParams, SegmentationTransform, Segmenter, Size, StatsOptions, SubscribableOptions, ThrottleOptions, Transform, UniversalAudioContextState, Unsubscribe$1 as Unsubscribe, VOICE_PROBABILITY_THRESHOLD, VideoProcessor, WasmPaths, WasmProcessorOptions, WasmWorkletNodeOptions, WorkletMessagePortOptions, WorkletModule, avg, calculateDistance, calculateFps, closedCurve, copyByteBufferToFloatBuffer, createAnalyzerGraphNode, createAnalyzerSubscribableGraphNode, createAsyncCallbackLoop, createAudioContext, createAudioDestinationGraphNode, createAudioGraph, createAudioGraphProxy, createAudioSignalDetector, createAudioStats, createBenchmark, createTransform as createCanvasTransform, createChannelMergerGraphNode, createChannelSplitterGraphNode, createDelayGraphNode, createDenoiseWorkletGraphNode, createFrameCallbackRequest, createGainGraphNode, createMediaElementSourceGraphNode, createSegmenter as createMediapipeSegmenter, createStreamDestinationGraphNode, createStreamSourceGraphNode, createVADetector, createVideoProcessor, createVideoTrackProcessor, createVideoTrackProcessorWithFallback, createVoiceDetectorFromProbability, createVoiceDetectorFromTimeData, curve, fitDestinationSize, fromByteToFloat, fromFloatToByte, getAudioStats, getBezierCurveControlPoints, isAnalyzerNodeInit, isAudioNode, isAudioNodeInit, isAudioParam, isClipping, isEqualSize, isLowVolume, isMono, isRenderEffects, isSegmentationModel, isSilent, isVoiceActivity, line, loadScript, loadTfjsBackendWebGl, loadTfjsCore, loadWasms, pow, processAverageVolume, resumeAudioOnInterruption, resumeAudioOnUnmute, rms, round, subscribeTimeoutAnalyzerNode, subscribeWorkletNode, sum, toDecibel, urls };