@ale-rainbow/web-sdk 5.1.0

package/lib/services/virtualBackground/RBVirtualBackground.service.d.ts

@@ -0,0 +1,228 @@
+import { BehaviorSubject, Subject } from "rxjs";
+/**
+ * How tight the auto-framing crop is: a single switch with four positions.
+ *
+ * 0 is the pure wide picture -- not a wide crop, but no crop and no measurement at all, which is
+ * why it is a level of this setting rather than a separate on/off flag. 1 to 3 are progressively
+ * tighter framings.
+ *
+ * Mirrors `AutoFrameZoom` in the virtual background worker: the SDK does not depend on the worker
+ * package, so the union is declared here and the two must stay in step.
+ */
+export type AutoFrameZoom = 0 | 1 | 2 | 3;
+export declare enum RBVirtualBackgroundBlurringLevel {
+    NORMAL = "normal",
+    DEEP = "deep"
+}
+export declare class RBVirtualBackgroundSettings {
+    modelAssetPath?: string;
+    wasmPath?: string;
+    videoWidth: number;
+    videoHeight: number;
+    framerate: number;
+    outputVideoWidth: number;
+    outputVideoHeight: number;
+    inlayRect: number[];
+    smoothMaskOn: boolean;
+    coverageMax: number;
+    coverageMin: number;
+    maskAverageDecayMin: number;
+    maskAverageDecayMax: number;
+    maskAverageDecayBoost: number;
+    maskAverageDecayThreshold: number;
+    filterOn: boolean;
+    /**
+     * In mask texels, but note gaussian() doubles it internally, so the real sigma is 4.0 here. The spatial
+     * term is consequently near-flat -- corner taps of the 5x5 weigh 0.78 against 1.0 at the centre (0.37 if
+     * this were 1.0). It discriminates little either way; colorWeight is what actually shapes the edge.
+     */
+    sigmaSpace: number;
+    /**
+     * Max luma gap (Rec.709) two taps may have and still blur together. Tuned on camera: 0.1 made the
+     * filter refuse to cross the contour at all, so the 256-wide mask's own grid showed through as
+     * staircased edges once backgroundStage upscaled it. 0.21 softens that without letting the mask
+     * bleed past the real edge -- which is what the misaligned sampling used to do.
+     *
+     * Caveat: 0.21 was tuned while the frame texture was still sampled NEAREST, so part of what it was
+     * absorbing was sampling noise rather than real edges. Now that the guide is filtered LINEAR it is
+     * likely too permissive -- worth re-tuning downwards from ~0.1.
+     */
+    sigmaColor: number;
+    /** Temporary A/B switch: false replays the historical, misaligned frame sampling in the filter. */
+    filterGeometryFix: boolean;
+    lightOn: boolean;
+    /**
+     * How much background colour bleeds onto the subject outline. The shader used to cube this, so 0.35
+     * actually delivered 0.043; it now applies once, making the same number ~8x stronger. Kept at 0.35 as
+     * a visible starting point -- it wants re-tuning on camera, likely downwards.
+     */
+    lightWrapping: number;
+    blendMode: number;
+    /**
+     * Dose, 0 to 1. 0 skips the stage entirely rather than running it as a pass-through, so the
+     * default costs nothing at all -- which is what makes it safe to ship off and enable per user.
+     *
+     * Off by default: the correction is only ever right for a badly lit room, and applying it to a
+     * well lit one flattens a picture that was already fine. Needs tuning on camera before it can be
+     * considered for a non-zero default; 0.6 is a sensible starting point when switching it on.
+     */
+    lightEnhanceStrength: number;
+    /**
+     * How much of the estimated illumination is divided out, 0 to 1. A full division is textbook
+     * Retinex and looks like a photocopy -- it removes the very shading that makes a face read as a
+     * solid object -- so this stays below 1 to keep some relief.
+     */
+    lightEnhanceGamma: number;
+    /**
+     * Gamma lift on the model's input, 1 meaning untouched. Around 1.8 lifts a dim room appreciably.
+     *
+     * Off by default like the rest: it wants measuring on camera against maskOnly, and a boost applied
+     * to an already well lit frame flattens the very contrast the segmenter keys on.
+     *
+     * A gamma rather than Retinex on purpose -- Retinex leaves halos along strong contrast edges, and
+     * those edges are exactly what the model keys on. Lifting shadows without moving any edge is what
+     * is wanted here; beauty is not.
+     */
+    modelInputBoost: number;
+    /**
+     * Debug view: display the 256x256 picture handed to the segmenter instead of the composited
+     * output, boost and letterbox bars included.
+     *
+     * The only direct way to judge modelInputBoost. Everywhere else that image is invisible by
+     * construction, so a boost that silently does nothing -- a browser ignoring ctx.filter, say --
+     * looks exactly like a boost that is working but too weak.
+     */
+    showModelInput: boolean;
+    maskOnly: boolean;
+    statsEnabled: boolean;
+    /** Head measurements averaged before the framing locks. 8 covers a fraction of a second. */
+    autoFrameCalibrationFrames: number;
+    /**
+     * The one framing switch:
+     *   0  pure wide -- the untouched picture: no crop, no recentring, nothing measured
+     *   1  head and bust, with headroom
+     *   2  head and shoulders
+     *   3  tight portrait, top of the head near the edge
+     *
+     * 0 by default: framing is opt-in, and opting out has to give back the camera picture exactly as
+     * it is, which is what makes 0 a bypass rather than merely the widest crop.
+     *
+     * Above 0, the crop never enlarges the picture by more than about 2.5x: past that the upscale is
+     * visible as soft pixels, and a slightly wider shot looks better than a blurry one.
+     */
+    autoFrameZoom: AutoFrameZoom;
+    /** Outline the measured head box instead of cropping -- for tuning the two factors above. */
+    autoFrameDebug: boolean;
+    constructor(modelAssetPath?: string, wasmPath?: string);
+}
+export declare class RBVirtualBackgroundStats {
+    /** Frames produced per second (output rate). */
+    fps: number;
+    /** Frames actually segmented per second. Below fps when throttling is active. */
+    segFps: number;
+    /** Segmentation rate the throttling aims for. segFps well below it means the machine can't keep up. */
+    desiredFps: number;
+    /** Mean inference time per segmented frame, in ms. */
+    inference: number;
+    /** Mean CPU time spent issuing the render pass, per segmented frame, in ms. */
+    postProc: number;
+    /** Mean time spent squaring the frame before inference (canvas alloc + drawImage), in ms. */
+    squaring: number;
+    /** Mean wall time between two consecutive inference calls, in ms. */
+    interval: number;
+    /** The framerate the worker believes the camera delivers -- the source of the throttling. */
+    framerate: number;
+}
+export declare class RBVirtualBackground {
+    private worker?;
+    private workerUrl;
+    private settings;
+    private trackProcessor?;
+    private trackGenerator?;
+    private bgVideoData;
+    private inputStream?;
+    private outputStream?;
+    private ackPromiseResolvers;
+    private ackPromiseRejecters;
+    private ackTimers;
+    /** Monotonic counter: a request id must be unique for the life of the instance, randomness is not needed. */
+    private ackRequestSeq;
+    outputStreamChange: Subject<MediaStream>;
+    stats: BehaviorSubject<RBVirtualBackgroundStats>;
+    /**
+     * Emits the worker's error when segmentation keeps failing: the output track is then still live but carries
+     * blank frames, so whoever publishes it must stop -- nothing else in the pipeline reports the failure.
+     */
+    processingFailed: Subject<string>;
+    private logger;
+    private static instance;
+    private constructor();
+    /**
+     * Create the Rainbow VirtualBackground Library singleton
+     */
+    static create(workerUrl?: string, modelAssetPath?: string, wasmPath?: string): Promise<RBVirtualBackground>;
+    /**
+     * Start processing
+     */
+    startProcessing(readableStream: ReadableStream, writableStream: WritableStream): Promise<void>;
+    /**
+     * Stop processing
+     */
+    stopProcessing(): Promise<void>;
+    /**
+     * Set the expected background blurring
+     * @param mode - mode (MAXIBLUR, BACKGROUND)
+     */
+    setBackgroundBlurring(level: RBVirtualBackgroundBlurringLevel): Promise<void>;
+    /**
+     * Permits to specify the background image URL
+     * @param imageUrl - the image url
+     */
+    setBackgroundImage(imageUrl: string): Promise<void>;
+    /**
+     * Permits to specify the video background url
+     * @param videoUrl - the backgroundvideo url
+     */
+    setBackgroundVideo(videoUrl: string): Promise<void>;
+    /**
+     * Permits to specify the video background stream
+     * @param stream - the backgroundvideo stream
+     */
+    setBackgroundStream(stream: MediaStream): Promise<void>;
+    /**
+     * Set the expected framerate
+     * @param framerate - framerate in fps
+     */
+    setFramerate(framerate: number): Promise<void>;
+    /**
+     * Permits to set the input mediaStream
+     * @param stream - The original media stream
+     * @returns The modified media stream
+     */
+    setInputStream(stream: MediaStream): Promise<MediaStream>;
+    /** @internal */
+    setSettings(settings?: RBVirtualBackgroundSettings): Promise<void>;
+    /**
+     * "Recenter me": measure the subject again from where they are now and freeze a new framing.
+     * The framing never follows the subject on its own, so this is how it is updated after moving.
+     *
+     * A no-op at zoom level 0, where there is no crop to recentre.
+     */
+    recenter(): Promise<void>;
+    /** @internal */
+    getSettings(): RBVirtualBackgroundSettings;
+    /** @internal */
+    getDefaultSettings(): RBVirtualBackgroundSettings;
+    private initialise;
+    private handlePromiseAck;
+    private handleOutputStream;
+    private workerAction;
+    /** Drop a pending ack and its timer. Safe to call twice. */
+    private clearAck;
+    private loadImage;
+    private imageToPixelData;
+    private removeBgVideoElements;
+    private removeBgVideoElement;
+    private loadBgVideo;
+}
+//# sourceMappingURL=RBVirtualBackground.service.d.ts.map

package/lib/services/virtualBackground/RBVirtualBackground.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RBVirtualBackground.service.d.ts","sourceRoot":"","sources":["../../../src/services/virtualBackground/RBVirtualBackground.service.ts"],"names":[],"mappings":"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"}

package/lib/services/virtualBackground/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./virtualBackground.service";
+export * from "./personalVideoBackground";
+export type { AutoFrameZoom } from "./RBVirtualBackground.service";
+//# sourceMappingURL=index.d.ts.map

package/lib/services/virtualBackground/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/virtualBackground/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,YAAY,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC"}

package/lib/services/virtualBackground/personalVideoBackground.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Setting key holding the JSON-serialized list of the user's personal video
+ * background file descriptor ids.
+ *
+ * @remarks The list is local to the browser: the video files themselves live on
+ * the Rainbow file storage, but the mapping "these files are my backgrounds" is
+ * not persisted server-side. Clearing the browser storage loses the list without
+ * deleting the files, which then stay on the server and keep counting against
+ * the user's quota.
+ */
+export declare const PERSONAL_VIDEO_BACKGROUND_IDS_SETTING: string;
+/**
+ * Prefix of the stable URI persisted as the selected background.
+ *
+ * A blob URL cannot be persisted: it dies with the document, so after a reload
+ * the background would fall back to black. We store `rainbow-vbg-file://{id}`
+ * instead and resolve it to a fresh blob URL when the video is actually wired.
+ */
+export declare const PERSONAL_VIDEO_BACKGROUND_URI_PREFIX: string;
+/** Maximum number of personal video backgrounds a user may store. */
+export declare const MAX_PERSONAL_VIDEO_BACKGROUNDS: number;
+/** Accepted MIME types for a personal video background. */
+export declare const PERSONAL_VIDEO_BACKGROUND_MIME_TYPES: readonly string[];
+/** Maximum accepted file size for a personal video background (20 MB). */
+export declare const MAX_PERSONAL_VIDEO_BACKGROUND_SIZE: number;
+/** A personal video background, as exposed to the GUI. */
+export interface PersonalVideoBackground {
+    /** Id of the underlying file descriptor. Also the identity used by the GUI. */
+    id: string;
+    /** Stable URI to persist as the selected background. Never a blob URL. */
+    uri: string;
+    /** Object URL of the server-generated snapshot, or `undefined` when unavailable. */
+    thumbnail?: string;
+    /** Original file name, used as accessible label. */
+    name: string;
+}
+/**
+ * Error codes thrown by {@link PersonalVideoBackgroundManager.addVideo}, so the
+ * GUI can pick the right toast without parsing a message.
+ */
+export declare enum PersonalVideoBackgroundError {
+    TOO_LARGE = "TOO_LARGE",
+    UNSUPPORTED_TYPE = "UNSUPPORTED_TYPE",
+    UNDECODABLE = "UNDECODABLE",
+    NOT_ENOUGH_SPACE = "NOT_ENOUGH_SPACE",
+    TOO_MANY = "TOO_MANY"
+}
+/**
+ * Builds the stable URI persisted for a personal video background.
+ * @param fileDescriptorId - Id of the file descriptor backing the video.
+ */
+export declare function buildPersonalVideoBackgroundUri(fileDescriptorId: string): string;
+/**
+ * Returns true when the given background url is a personal video background URI.
+ * Shipped videos keep their plain `/cacheV2/...` path and are left untouched.
+ * @param url - The background url to test.
+ */
+export declare function isPersonalVideoBackgroundUri(url: string | undefined): boolean;
+/**
+ * Extracts the file descriptor id out of a personal video background URI.
+ * @param uri - The URI to parse.
+ * @returns The file descriptor id, or `undefined` when the URI is not one of ours.
+ */
+export declare function parsePersonalVideoBackgroundUri(uri: string | undefined): string | undefined;
+/**
+ * @module VirtualBackground
+ * Manages the user's own video backgrounds: upload to the Rainbow file storage,
+ * listing, deletion, and resolution of a stored id into a playable blob URL.
+ *
+ * @remarks This is a plain helper owned by the virtual background service, not a
+ * registered `Service`: it has no lifecycle of its own beyond releasing the
+ * object URLs it hands out.
+ */
+export declare class PersonalVideoBackgroundManager {
+    private readonly logger;
+    private readonly settingsService;
+    private readonly contactService;
+    private readonly fileStorageService;
+    private readonly fileServerService;
+    /** Object URLs handed out, by file descriptor id, so they can be revoked. */
+    private readonly objectUrls;
+    /** Object URLs of the thumbnails currently displayed, by file descriptor id. */
+    private readonly thumbnailUrls;
+    /**
+     * Reads the stored id list.
+     * @returns The stored ids, or an empty array when unset or corrupted.
+     */
+    getVideoIds(): string[];
+    private setVideoIds;
+    /**
+     * Storage key for the connected user.
+     *
+     * The list is scoped per user: the ids point at files owned by whoever uploaded them, and
+     * the server answers 403 for anybody else. Sharing one key across accounts on the same
+     * browser made a second user inherit — and never be able to resolve — the first one's videos.
+     */
+    private storageKey;
+    /**
+     * Reads the stored list, falling back to the legacy unscoped key once so a user who already
+     * has videos keeps them, then migrating that value under their own key.
+     */
+    private readRawIds;
+    /**
+     * Uploads a video file and registers it as a personal video background.
+     * @param file - The video file picked by the user.
+     * @returns The newly created background.
+     * @throws {PersonalVideoBackgroundError} When the file is rejected before upload.
+     */
+    addVideo(file: File): Promise<PersonalVideoBackground>;
+    /**
+     * Resolves every stored id into a background descriptor.
+     *
+     * @remarks Dead ids are tolerated: a file deleted elsewhere, or purged by a
+     * quota cleanup, is dropped from the list instead of breaking the whole
+     * selector.
+     * @returns The backgrounds still resolvable, in stored order.
+     */
+    listVideos(): Promise<PersonalVideoBackground[]>;
+    /**
+     * True while at least one video is still waiting for its server-generated snapshot.
+     *
+     * The snapshot lands a few seconds after the upload, so the tile shows a placeholder until
+     * then and the caller can poll on this.
+     */
+    hasPendingThumbnail(): boolean;
+    /**
+     * Re-reads a video's descriptor from the server, bypassing the cache, and picks up its
+     * snapshot if it has been generated since.
+     * @param id - Id of the file descriptor to refresh.
+     * @returns True when a thumbnail is now available.
+     */
+    refreshThumbnail(id: string): Promise<boolean>;
+    /**
+     * Same as {@link listVideos}, plus whether some ids could not be resolved for a reason that
+     * may fix itself — which tells the caller it is worth trying again.
+     */
+    listVideosWithStatus(): Promise<{
+        videos: PersonalVideoBackground[];
+        hasTransientFailure: boolean;
+    }>;
+    /**
+     * Deletes a personal video background, server-side and from the local list.
+     *
+     * @remarks The id is dropped from the list even when the server call fails,
+     * otherwise a file already gone would stay stuck in the selector forever.
+     * @param id - Id of the file descriptor to delete.
+     */
+    deleteVideo(id: string): Promise<void>;
+    /**
+     * Downloads a personal video background and exposes it as a playable blob URL.
+     *
+     * @remarks The returned URL is cached per id and revoked by {@link release}
+     * or {@link cleanUp}: an unreleased object URL pins the whole video in memory.
+     * @param id - Id of the file descriptor to resolve.
+     * @returns The blob URL, or `undefined` when the file no longer resolves.
+     */
+    getVideoUrl(id: string): Promise<string | undefined>;
+    /**
+     * Resolves a background url into something playable.
+     * @param url - Either a personal video URI, or a plain url left untouched.
+     * @returns The resolved url, or `undefined` when a personal video is gone.
+     */
+    resolveBackgroundUrl(url: string): Promise<string | undefined>;
+    /**
+     * Revokes the object URLs held for one background.
+     * @param id - Id of the file descriptor to release.
+     */
+    release(id: string): void;
+    /** Revokes every object URL handed out so far. */
+    cleanUp(): void;
+    /**
+     * Checks the browser can actually decode the file, by loading its metadata
+     * in a detached `<video>` element.
+     * @param file - The file to probe.
+     */
+    private isDecodable;
+    /**
+     * Maps a file descriptor to the shape the GUI consumes, resolving its
+     * server-generated snapshot when one is available.
+     * @param fileDescriptor - The descriptor to map.
+     */
+    private toPersonalVideoBackground;
+    /**
+     * Resolves the snapshot the server generates when a video is uploaded.
+     * @param fileDescriptor - The descriptor whose thumbnail is wanted.
+     * @returns An object URL, or `undefined` when no snapshot is available yet.
+     */
+    private getThumbnailUrl;
+}
+//# sourceMappingURL=personalVideoBackground.d.ts.map

package/lib/services/virtualBackground/personalVideoBackground.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"personalVideoBackground.d.ts","sourceRoot":"","sources":["../../../src/services/virtualBackground/personalVideoBackground.ts"],"names":[],"mappings":"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"}

package/lib/services/virtualBackground/pipeline/canvas2D/canvas2DPipeline.d.ts

@@ -0,0 +1,66 @@
+import type { IVideoPipeline } from "../../../../services/virtualBackground/virtualBackground.service";
+export declare class Canvas2DPipeline implements IVideoPipeline {
+    private vbService;
+    private logger;
+    private segmentationPixelCount;
+    private tflite;
+    private segmentationMaskCtx;
+    private segmentationMask;
+    private outputCanvasCtx;
+    private segmentationMaskCanvas;
+    maskFrameTimerWorker: Worker;
+    virtualImage: CanvasImageSource;
+    virtualVideo: CanvasImageSource;
+    /**
+     * @function create
+     * @static
+     * @public
+     * @returns {Canvas2DPipeline} Initialization of the class
+     */
+    static create(virtualBackgroundService: any): Canvas2DPipeline;
+    private constructor();
+    /**
+     * @function init
+     * @public
+     * @async
+     * @description Retrieve the image or video to be used as a background
+     */
+    init(): Promise<any>;
+    private loadImage;
+    /**
+     * @function render
+     * @public
+     * @async
+     * @description Calls the different methods to create the virtual background
+     */
+    render(): Promise<void>;
+    updatePostProcessingConfig(): void;
+    /**
+     * @function cleanUp
+     * @public
+     * @description deletes the canvas created for the mask
+     */
+    cleanUp(): void;
+    /** **************************************************************************/
+    /** PUBLIC STUFF                                                           **/
+    /** **************************************************************************/
+    /**
+     * @function runPreProcessing
+     * @private
+     * @description Resize the mask and send the data to tflite
+     */
+    private runPreProcessing;
+    /**
+     * @function runInference
+     * @private
+     * @description Recovery of the AI data and application of the softMax equiation to create the mask
+     */
+    private runInference;
+    /**
+     * @function runPostProcessing
+     * @private
+     * @description Finalization of the virtual background
+     */
+    private runPostProcessing;
+}
+//# sourceMappingURL=canvas2DPipeline.d.ts.map

package/lib/services/virtualBackground/pipeline/canvas2D/canvas2DPipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas2DPipeline.d.ts","sourceRoot":"","sources":["../../../../../src/services/virtualBackground/pipeline/canvas2D/canvas2DPipeline.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2EAA2E,CAAC;AAIhH,qBAAa,gBAAiB,YAAW,cAAc;IACnD,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,MAAM,CAA8C;IAC5D,OAAO,CAAC,sBAAsB,CAAS;IACvC,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,mBAAmB,CAA2B;IACtD,OAAO,CAAC,gBAAgB,CAAM;IAC9B,OAAO,CAAC,eAAe,CAA2B;IAClD,OAAO,CAAC,sBAAsB,CAAoB;IAE3C,oBAAoB,EAAE,MAAM,CAAC;IAC7B,YAAY,EAAE,iBAAiB,CAAC;IAChC,YAAY,EAAE,iBAAiB,CAAC;IAEvC;;;;;OAKG;WACW,MAAM,CAAC,wBAAwB,EAAE,GAAG,GAAG,gBAAgB;IAIrE,OAAO;IAIP;;;;;OAKG;IACU,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC;IAiCjC,OAAO,CAAC,SAAS;IAUjB;;;;;OAKG;IACU,MAAM;IAUZ,0BAA0B;IAEjC;;;;OAIG;IACI,OAAO;IAId,+EAA+E;IAC/E,8EAA8E;IAC9E,+EAA+E;IAE/E;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAWxB;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAiBpB;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;CA0B5B"}

package/lib/services/virtualBackground/pipeline/webgl2/blurStage.d.ts

@@ -0,0 +1,88 @@
+import type { Webgl2Pipeline } from "../../../../services/virtualBackground/pipeline/webgl2/webgl2Pipeline";
+export interface BackgroundBlurStage {
+    render: () => void;
+    updateCoverage: (coverage: [number, number]) => void;
+    cleanUp: () => void;
+}
+export declare class BlurStage {
+    private blur;
+    private blend;
+    /**
+     * @function create
+     * @static
+     * @public
+     * @param {Options} options The options (type and url) of the image or the video
+     * @param {Webgl2Pipeline} vbWebgl2 The instance of the webgl2 class
+     * @returns {BlurStage | null} Initialization of the class
+     */
+    static create(options: any, vbWebgl2: Webgl2Pipeline): BlurStage;
+    private constructor();
+    /** **************************************************************************/
+    /** PUBLIC STUFF                                                           **/
+    /** **************************************************************************/
+    /** **************************************************************************/
+    /** PRIVATE STUFF                                                          **/
+    /** **************************************************************************/
+    render(): void;
+    updateCoverage(coverage: [number, number]): void;
+    cleanUp(): void;
+}
+export declare class BlurPass {
+    private vbHelper;
+    private vbWebgl2;
+    program: any;
+    private outputWidth;
+    private outputHeight;
+    private inputFrameLocation;
+    private personMaskLocation;
+    private texelSizeLocation;
+    private texelHeight;
+    private texelWidth;
+    private texture1;
+    private texture2;
+    private frameBuffer1;
+    private frameBuffer2;
+    private fragmentShaderBlur;
+    private gl;
+    private options;
+    constructor(vbWebgl2: Webgl2Pipeline, options: any);
+    /**
+     * @function render
+     * @public
+     */
+    render(): void;
+    /**
+     * @function cleanUp
+     * @public
+     * @description removes the different components used to make the assembly with the blurring of the environment
+     */
+    cleanUp(): void;
+}
+export declare class BlendPass {
+    private vbWebgl2;
+    private vbHelper;
+    private vertexShaderBlend;
+    private fragmentShaderBlend;
+    private program;
+    private coverageLocation;
+    private gl;
+    constructor(vbWebgl2: Webgl2Pipeline);
+    /**
+     * @function render
+     * @public
+     */
+    render(): void;
+    /**
+     * @function updateCoverage
+     * @public
+     * @param {[number, number]} coverage
+     */
+    updateCoverage(coverage: [number, number]): void;
+    /**
+     * @function cleanUp
+     * @public
+     * @description removes the different components used to make the assembly with the blurring of the environment
+     */
+    cleanUp(): void;
+}
+//# sourceMappingURL=blurStage.d.ts.map

package/lib/services/virtualBackground/pipeline/webgl2/blurStage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blurStage.d.ts","sourceRoot":"","sources":["../../../../../src/services/virtualBackground/pipeline/webgl2/blurStage.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gFAAgF,CAAC;AAGrH,MAAM,WAAW,mBAAmB;IAChC,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,cAAc,EAAE,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,IAAI,CAAC;IACrD,OAAO,EAAE,MAAM,IAAI,CAAC;CACvB;AAED,qBAAa,SAAS;IAClB,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,KAAK,CAAM;IAEnB;;;;;;;OAOG;WACW,MAAM,CAAC,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,cAAc,GAAG,SAAS;IAMvE,OAAO;IAKP,+EAA+E;IAC/E,8EAA8E;IAC9E,+EAA+E;IAG/E,+EAA+E;IAC/E,8EAA8E;IAC9E,+EAA+E;IAExE,MAAM;IAKN,cAAc,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;IAIzC,OAAO;CAIjB;AACD,qBAAa,QAAQ;IACjB,OAAO,CAAC,QAAQ,CAAc;IAC9B,OAAO,CAAC,QAAQ,CAAiB;IAC1B,OAAO,EAAE,GAAG,CAAC;IACpB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,kBAAkB,CAAuB;IACjD,OAAO,CAAC,kBAAkB,CAAuB;IACjD,OAAO,CAAC,iBAAiB,CAAuB;IAChD,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,QAAQ,CAAe;IAC/B,OAAO,CAAC,QAAQ,CAAe;IAC/B,OAAO,CAAC,YAAY,CAAmB;IACvC,OAAO,CAAC,YAAY,CAAmB;IACvC,OAAO,CAAC,kBAAkB,CAAc;IACxC,OAAO,CAAC,EAAE,CAAyB;IACnC,OAAO,CAAC,OAAO,CAAM;gBAET,QAAQ,EAAE,cAAc,EAAE,OAAO,EAAE,GAAG;IA0IlD;;;OAGG;IACI,MAAM;IAwBb;;;;OAIG;IACI,OAAO;CAcjB;AACD,qBAAa,SAAS;IAClB,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,QAAQ,CAAc;IAC9B,OAAO,CAAC,iBAAiB,CAAc;IACvC,OAAO,CAAC,mBAAmB,CAAc;IACzC,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,gBAAgB,CAAuB;IAC/C,OAAO,CAAC,EAAE,CAAyB;gBAEvB,QAAQ,EAAE,cAAc;IAuDpC;;;OAGG;IACI,MAAM;IASb;;;;OAIG;IACI,cAAc,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;IAKhD;;;;OAIG;IACI,OAAO;CAQjB"}

package/lib/services/virtualBackground/pipeline/webgl2/imageStage.d.ts

@@ -0,0 +1,69 @@
+import type { Webgl2Pipeline } from "./webgl2Pipeline";
+export declare class ImageStage {
+    private vbWebgl2;
+    private vbHelper;
+    private vertexShaderImage;
+    private fragmentShaderImage;
+    private program;
+    private backgroundTexture;
+    private outputRatio;
+    private backgroundLocation;
+    private backgroundScaleLocation;
+    private backgroundOffsetLocation;
+    private coverageLocation;
+    private lightWrappingLocation;
+    private blendModeLocation;
+    private gl;
+    private video;
+    private options;
+    /**
+     * @function create
+     * @static
+     * @public
+     * @param {Options} options The options (type and url) of the image or the video
+     * @param {Webgl2Pipeline} vbWebgl2 The instance of the webgl2 class
+     * @returns {ImageStage | null} Initialization of the class
+     */
+    static create(options: any, vbWebgl2: Webgl2Pipeline): Promise<ImageStage | null>;
+    private constructor();
+    /**
+     * @function render
+     * @public
+     * @description Assembles the mask with the person's video stream and the virtual background image
+     */
+    render(): void;
+    /**
+     * @function updateCoverage
+     * @public
+     * @param {[number, number]} coverage
+     */
+    updateCoverage(coverage: [number, number]): void;
+    /**
+     * @function updateLightWrapping
+     * @public
+     * @param {number} lightWrapping The lightWrapping parameter
+     * @description Light wrapping is a compositing technique designed to blend keyed out green screen footage with a background plate
+     */
+    updateLightWrapping(lightWrapping: number): void;
+    /**
+     * @function updateBlendMode
+     * @public
+     * @param {BlendMode} blendMode The mode that will apply
+     * @description determines how the two layers will be blended together.
+     */
+    updateBlendMode(blendMode: number): void;
+    /**
+     * @function cleanUp
+     * @public
+     * @description removes the different components used to make the assembly with the image
+     */
+    cleanUp(): void;
+    /**
+     * @function updateBackgroundImage
+     * @public
+     * @param {any} background An HTMLLImageElement or HTMLVideoElement that contains the virtual background that will be placed behind the person
+     * @description Resize the virtual background to the right size
+     */
+    updateBackgroundImage(background: any): void;
+}
+//# sourceMappingURL=imageStage.d.ts.map