@pexip/media-processor 16.7.1 → 17.0.0

package/dist/main/video/utils.d.ts

@@ -0,0 +1,102 @@
+/// <reference types="dom-webcodecs" />
+import type { Tensor3D } from '@tensorflow/tfjs-core';
+/**
+ * We support several ways to get image inputs.
+ */
+export type InputImage = HTMLVideoElement | HTMLImageElement | HTMLCanvasElement;
+import type { Size, Rect, Frame, Canvas, CanvasContext, Callback } from '../types';
+import { subscribeVisibilityChangeEvent } from '../utils';
+import type { MaskUnderlyingType, Segmentation, Color, ImageType, ProcessInputType } from './types';
+/**
+ * Draw the source onto the provided canvas according to the destination rect
+ *
+ * @param canvasContext - A buffer canvas used for drawing the frame
+ * @param source - Source to take the frame from
+ * @param destination - A destination rect to be draw on the canvas
+ */
+export declare const drawFrame: (canvasContext: CanvasContext, source: Frame, destination: Rect) => void;
+/**
+ * Taking a frame from the source and return the `ImageData`
+ *
+ * @param canvasContext - A buffer canvas used for drawing the frame
+ * @param source - Source to take the frame from
+ * @param destination - A destination rect to be draw on the canvas for getting the
+ * data
+ */
+export declare const takeFrame: (canvasContext: CanvasContext, source: Frame, destination: Rect) => ImageData;
+/**
+ * Draw provided ImageData onto a canvas. This is just a wrapper of
+ * `putImageData` with both `dx` and `dy` set to 0
+ *
+ * @param canvasContext - The canvas context to draw on
+ * @param data - The data to draw
+ */
+export declare const drawImageData: (canvasContext: CanvasContext, data: ImageData) => void;
+/**
+ * Create a Canvas element with provided width and height
+ *
+ * @param width - canvas.width
+ * @param height - canvas.height
+ */
+export declare const createCanvas: (width: number, height: number) => HTMLCanvasElement;
+/**
+ * Create an OffscreenCanvas with provided width and height. When
+ * OffscreenCanvas is not available, a Canvas element is returned.
+ *
+ * @param width - canvas.width
+ * @param height - canvas.height
+ */
+export declare const createOffscreenCanvas: (width: number, height: number) => HTMLCanvasElement | OffscreenCanvas;
+/**
+ * Create a video element with provided width and height, and set it to muted
+ *
+ * @param width - video.width
+ * @param height - video.height
+ */
+export declare const createVideoElement: (width: number, height: number) => HTMLVideoElement;
+export declare const setVideoElementSrc: (video: HTMLVideoElement, src: MediaProvider) => void;
+export declare const toVideoElement: (input: MediaStream, width: number, height: number) => HTMLVideoElement;
+export declare const playVideo: (video: HTMLVideoElement) => Promise<void>;
+/**
+ * Load image with provided image element
+ */
+export declare const loadImage: (image: HTMLImageElement, src: string) => Promise<void>;
+export declare const toNumber: (value: number | SVGAnimatedLength) => number;
+export declare const getCanvasRenderingContext2D: (canvas: Canvas, options?: CanvasRenderingContext2DSettings) => CanvasRenderingContext2D;
+export declare const getImageSize: (image: VideoFrame | CanvasImageSource | OffscreenCanvas | ImageData | SVGImageElement | Tensor3D) => Size;
+export declare const toHTMLCanvasElementLossy: (image: ImageData | SVGImageElement | OffscreenCanvas | Tensor3D) => Promise<HTMLCanvasElement>;
+export declare const toImageDataLossy: (image: CanvasImageSource | Tensor3D) => Promise<ImageData>;
+export declare const toTensorLossy: (image: CanvasImageSource | ImageData) => Promise<Tensor3D>;
+/**
+ * Construct a Segmentation object with tensorflow-models/shared utils
+ */
+export declare const toSegmentation: (data: CanvasImageSource | ImageData | Tensor3D, type: MaskUnderlyingType, maskValueToLabel: (value: number) => string) => Segmentation;
+export declare const flipCanvasHorizontal: (canvas: Canvas) => void;
+export declare const drawStroke: (bytes: Uint8ClampedArray, row: number, column: number, width: number, radius: number, color?: Color) => void;
+export declare const isSegmentationBoundary: (data: Uint8ClampedArray, row: number, column: number, width: number, isForegroundId: boolean[], alphaCutoff: number, radius?: number) => boolean;
+export declare const toBinaryMask: (segmentation: Segmentation | Segmentation[], foreground?: Color, background?: Color, drawContour?: boolean, foregroundThreshold?: number, foregroundMaskValues?: number[]) => Promise<ImageData | null>;
+type Draw = (input: ImageType) => Promise<Canvas>;
+export declare const createInputImageConvertor: (draw: Draw) => (input: ProcessInputType) => Promise<InputImage>;
+export declare const ensure: <T>(prop: T, message?: string) => NonNullable<T>;
+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
+ */
+export declare const createFrameCallbackRequest: (callback: Callback<Promise<void>, [ProcessInputType]>, frameRate: number, { subscribeVisibilityChange, }?: FrameCallbackRequestOptions) => {
+    start: (input: ProcessInputType) => Promise<void>;
+    stop: () => void;
+    frameRate: number;
+};
+export {};

package/dist/main/video/utils.js

@@ -0,0 +1,476 @@
+import { Tensor, browser } from '@tensorflow/tfjs-core/dist/base.js';
+import { createAsyncCallbackLoop, subscribeVisibilityChangeEvent, } from '../utils';
+/**
+ * Draw the source onto the provided canvas according to the destination rect
+ *
+ * @param canvasContext - A buffer canvas used for drawing the frame
+ * @param source - Source to take the frame from
+ * @param destination - A destination rect to be draw on the canvas
+ */
+export const drawFrame = (canvasContext, source, destination) => {
+    canvasContext.drawImage(source.source, 0, 0, source.width, source.height, destination.x, destination.y, destination.width, destination.height);
+};
+/**
+ * Taking a frame from the source and return the `ImageData`
+ *
+ * @param canvasContext - A buffer canvas used for drawing the frame
+ * @param source - Source to take the frame from
+ * @param destination - A destination rect to be draw on the canvas for getting the
+ * data
+ */
+export const takeFrame = (canvasContext, source, destination) => {
+    drawFrame(canvasContext, source, destination);
+    return canvasContext.getImageData(0, 0, destination.width, destination.height);
+};
+/**
+ * Draw provided ImageData onto a canvas. This is just a wrapper of
+ * `putImageData` with both `dx` and `dy` set to 0
+ *
+ * @param canvasContext - The canvas context to draw on
+ * @param data - The data to draw
+ */
+export const drawImageData = (canvasContext, data) => {
+    canvasContext.putImageData(data, 0, 0);
+};
+/**
+ * Create a Canvas element with provided width and height
+ *
+ * @param width - canvas.width
+ * @param height - canvas.height
+ */
+export const createCanvas = (width, height) => {
+    const canvas = document.createElement('canvas');
+    canvas.width = width;
+    canvas.height = height;
+    return canvas;
+};
+/**
+ * Create an OffscreenCanvas with provided width and height. When
+ * OffscreenCanvas is not available, a Canvas element is returned.
+ *
+ * @param width - canvas.width
+ * @param height - canvas.height
+ */
+export const createOffscreenCanvas = (width, height) => {
+    try {
+        const offscreen = new OffscreenCanvas(width, height);
+        return offscreen;
+    }
+    catch {
+        return createCanvas(width, height);
+    }
+};
+/**
+ * Create a video element with provided width and height, and set it to muted
+ *
+ * @param width - video.width
+ * @param height - video.height
+ */
+export const createVideoElement = (width, height) => {
+    const video = document.createElement('video');
+    video.width = width;
+    video.height = height;
+    video.muted = true;
+    return video;
+};
+export const setVideoElementSrc = (video, src) => {
+    let url = '';
+    const revokeObjectURL = () => {
+        if (url) {
+            URL.revokeObjectURL(url);
+        }
+    };
+    if (src instanceof MediaStream) {
+        src.getVideoTracks().forEach(track => {
+            track.addEventListener('ended', revokeObjectURL);
+        });
+    }
+    if ('MediaSource' in window && src instanceof MediaSource) {
+        src.addEventListener('sourceended', revokeObjectURL);
+    }
+    // https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/srcObject
+    try {
+        video.srcObject = src;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.name === 'TypeError') {
+                throw error;
+            }
+            if (('MediaSource' in window && src instanceof MediaSource) ||
+                src instanceof Blob) {
+                url = URL.createObjectURL(src);
+            }
+            video.src = url;
+        }
+    }
+};
+export const toVideoElement = (input, width, height) => {
+    const [settings = {}] = input
+        .getVideoTracks()
+        .map(track => track.getSettings());
+    const video = createVideoElement(settings.width ?? width, settings.height ?? height);
+    video.playsInline = true;
+    setVideoElementSrc(video, input);
+    return video;
+};
+var HTMLMediaElementReadyState;
+(function (HTMLMediaElementReadyState) {
+    HTMLMediaElementReadyState[HTMLMediaElementReadyState["HaveNothing"] = 0] = "HaveNothing";
+    HTMLMediaElementReadyState[HTMLMediaElementReadyState["HaveMetaData"] = 1] = "HaveMetaData";
+    HTMLMediaElementReadyState[HTMLMediaElementReadyState["HaveCurrentData"] = 2] = "HaveCurrentData";
+    HTMLMediaElementReadyState[HTMLMediaElementReadyState["HaveFutureData"] = 3] = "HaveFutureData";
+    HTMLMediaElementReadyState[HTMLMediaElementReadyState["HaveEnoughData"] = 4] = "HaveEnoughData";
+})(HTMLMediaElementReadyState || (HTMLMediaElementReadyState = {}));
+export const playVideo = async (video) => {
+    if (video.autoplay) {
+        return;
+    }
+    if (video.readyState < HTMLMediaElementReadyState.HaveCurrentData) {
+        // Not enough data, wait for the data and then play
+        await Promise.race([
+            new Promise(resolve => {
+                const waitForEvent = () => {
+                    video.removeEventListener('loadeddata', waitForEvent);
+                    resolve();
+                };
+                video.addEventListener('loadeddata', waitForEvent);
+            }),
+            // Use setTimeout to prevent a race to `loadeddata` event
+            new Promise(resolve => {
+                setTimeout(() => {
+                    resolve();
+                }, 3000);
+            }),
+        ]);
+    }
+    return await video.play();
+};
+/**
+ * Load image with provided image element
+ */
+export const loadImage = async (image, src) => {
+    image.src = src;
+    return new Promise((resolve, reject) => {
+        image.onload = () => resolve();
+        image.onerror = reject;
+    });
+};
+export const toNumber = (value) => value instanceof SVGAnimatedLength ? value.baseVal.value : value;
+export const getCanvasRenderingContext2D = (canvas, options) => {
+    const context = canvas.getContext('2d', options);
+    if (!context) {
+        throw new Error('Cannot get CanvasRenderingContext2D');
+    }
+    return context;
+};
+export const getImageSize = (image) => {
+    if (image instanceof Tensor) {
+        const [height = 0, width = 0] = image.shape.slice(0, 2);
+        return { height, width };
+    }
+    if ('VideoFrame' in window && image instanceof VideoFrame) {
+        return { height: image.displayHeight, width: image.displayWidth };
+    }
+    if ('offsetHeight' in image &&
+        image.offsetHeight !== 0 &&
+        'offsetWidth' in image &&
+        image.offsetWidth !== 0) {
+        return { height: image.offsetHeight, width: image.offsetWidth };
+    }
+    if ('height' in image &&
+        image.height !== 0 &&
+        'width' in image &&
+        image.width !== 0) {
+        return { height: toNumber(image.height), width: toNumber(image.width) };
+    }
+    throw new Error('Unknown input image');
+};
+export const toHTMLCanvasElementLossy = async (image) => {
+    const { width, height } = getImageSize(image);
+    const canvas = createCanvas(width, height);
+    if (image instanceof Tensor) {
+        await browser.toPixels(image, canvas);
+        return canvas;
+    }
+    const context = getCanvasRenderingContext2D(canvas);
+    if (image instanceof ImageData) {
+        context.putImageData(image, 0, 0);
+    }
+    else {
+        context.drawImage(image, 0, 0);
+    }
+    return canvas;
+};
+export const toImageDataLossy = async (image) => {
+    const { width, height } = getImageSize(image);
+    if (image instanceof Tensor) {
+        return new ImageData(await browser.toPixels(image), width, height);
+    }
+    const canvas = createOffscreenCanvas(width, height);
+    const context = getCanvasRenderingContext2D(canvas);
+    context.drawImage(image, 0, 0);
+    return context.getImageData(0, 0, canvas.width, canvas.height);
+};
+export const toTensorLossy = async (image) => {
+    const pixelsInput = image instanceof SVGImageElement || image instanceof OffscreenCanvas
+        ? await toHTMLCanvasElementLossy(image)
+        : image;
+    return browser.fromPixels(pixelsInput, 4);
+};
+/**
+ * Construct a Segmentation object with tensorflow-models/shared utils
+ */
+export const toSegmentation = (data, type, maskValueToLabel) => {
+    const mask = {
+        toCanvasImageSource: async () => {
+            if (data instanceof HTMLCanvasElement) {
+                return data;
+            }
+            if (data instanceof HTMLVideoElement ||
+                data instanceof ImageBitmap ||
+                data instanceof HTMLImageElement) {
+                const canvas = createCanvas(data.width, data.height);
+                const context = canvas.getContext('2d');
+                context?.drawImage(data, 0, 0, data.width, data.height);
+                return canvas;
+            }
+            return await toHTMLCanvasElementLossy(data);
+        },
+        toImageData: async () => {
+            if (data instanceof ImageData) {
+                return data;
+            }
+            return await toImageDataLossy(data);
+        },
+        toTensor: async () => {
+            if (data instanceof Tensor) {
+                return data;
+            }
+            return await toTensorLossy(data);
+        },
+        getUnderlyingType: () => type,
+    };
+    return {
+        maskValueToLabel,
+        mask,
+    };
+};
+export const flipCanvasHorizontal = (canvas) => {
+    const ctx = getCanvasRenderingContext2D(canvas);
+    ctx.scale(-1, 1);
+    ctx.translate(-canvas.width, 0);
+};
+export const drawStroke = (bytes, row, column, width, radius, color = {
+    r: 0,
+    g: 255,
+    b: 255,
+    a: 255,
+}) => {
+    for (let i = -radius; i <= radius; i++) {
+        for (let j = -radius; j <= radius; j++) {
+            if (i !== 0 && j !== 0) {
+                const n = (row + i) * width + (column + j);
+                bytes[4 * n + 0] = color.r;
+                bytes[4 * n + 1] = color.g;
+                bytes[4 * n + 2] = color.b;
+                bytes[4 * n + 3] = color.a;
+            }
+        }
+    }
+};
+export const isSegmentationBoundary = (data, row, column, width, isForegroundId, alphaCutoff, radius = 1) => {
+    let numberBackgroundPixels = 0;
+    for (let i = -radius; i <= radius; i++) {
+        for (let j = -radius; j <= radius; j++) {
+            if (i !== 0 && j !== 0) {
+                const n = (row + i) * width + (column + j);
+                const foregroundColor = data[4 * n];
+                const alphaColor = data[4 * n + 3];
+                if ((foregroundColor !== undefined &&
+                    !isForegroundId[foregroundColor]) ||
+                    (alphaColor !== undefined && alphaColor < alphaCutoff)) {
+                    numberBackgroundPixels += 1;
+                }
+            }
+        }
+    }
+    return numberBackgroundPixels > 0;
+};
+export const toBinaryMask = async (segmentation, foreground = {
+    r: 0,
+    g: 0,
+    b: 0,
+    a: 0,
+}, background = {
+    r: 0,
+    g: 0,
+    b: 0,
+    a: 255,
+}, drawContour = false, foregroundThreshold = 0.5, foregroundMaskValues = Array.from(Array(256).keys())) => {
+    const segmentations = !Array.isArray(segmentation)
+        ? [segmentation]
+        : segmentation;
+    if (segmentations.length === 0) {
+        return null;
+    }
+    const masks = await Promise.all(segmentations.map(segmentation => segmentation.mask.toImageData()));
+    const [imageData] = masks;
+    if (!imageData) {
+        return null;
+    }
+    const { width, height } = imageData;
+    const bytes = new Uint8ClampedArray(width * height * 4);
+    const alphaCutoff = Math.round(255 * foregroundThreshold);
+    const isForegroundId = new Array(256).fill(false);
+    foregroundMaskValues.forEach(id => (isForegroundId[id] = true));
+    for (let i = 0; i < height; i++) {
+        for (let j = 0; j < width; j++) {
+            const n = i * width + j;
+            bytes[4 * n + 0] = background.r;
+            bytes[4 * n + 1] = background.g;
+            bytes[4 * n + 2] = background.b;
+            bytes[4 * n + 3] = background.a;
+            for (const mask of masks) {
+                const maskForegroundColor = mask.data[4 * n];
+                const maskAlphaColor = mask.data[4 * n + 3];
+                if (maskForegroundColor !== undefined &&
+                    isForegroundId[maskForegroundColor] &&
+                    maskAlphaColor !== undefined &&
+                    maskAlphaColor >= alphaCutoff) {
+                    bytes[4 * n] = foreground.r;
+                    bytes[4 * n + 1] = foreground.g;
+                    bytes[4 * n + 2] = foreground.b;
+                    bytes[4 * n + 3] = foreground.a;
+                    if (drawContour &&
+                        i - 1 >= 0 &&
+                        i + 1 < height &&
+                        j - 1 >= 0 &&
+                        j + 1 < width &&
+                        isSegmentationBoundary(mask.data, i, j, width, isForegroundId, alphaCutoff)) {
+                        drawStroke(bytes, i, j, width, 1);
+                    }
+                }
+            }
+        }
+    }
+    return new ImageData(bytes, width, height);
+};
+export const createInputImageConvertor = (draw) => async (input) => {
+    return (input instanceof ImageData || input instanceof ImageBitmap
+        ? await draw(input)
+        : input);
+};
+export const ensure = (prop, message = 'Processor is not opened, please call open() method first') => {
+    if (!prop) {
+        throw new Error(message);
+    }
+    return prop;
+};
+/**
+ * Feature detection to detect if there is requestVideoFrameCallback API
+ * available as well as the input is an HTMLVideoElement
+ *
+ * @param input - An input to be verified for the feature
+ */
+const hasRequestVideoFrameCallback = (input) => typeof input === 'object' &&
+    input instanceof HTMLVideoElement &&
+    'requestVideoFrameCallback' in HTMLVideoElement.prototype;
+/**
+ * Get the estimated video frame rate from HTMLVideoElement, otherwise returns
+ * a fallback rate provided by.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement/getVideoPlaybackQuality}
+ *
+ * @param input - The input to be verified if the `getVideoPlaybackQuality` API
+ * is available
+ * @param frameRate - A fallback rate to be used when the API is not available
+ */
+const getFrameRate = (input, frameRate) => {
+    if (input instanceof HTMLVideoElement) {
+        const quality = input.getVideoPlaybackQuality();
+        return (input.mozPresentedFrames ||
+            quality.totalVideoFrames - quality.droppedVideoFrames);
+    }
+    return frameRate;
+};
+/**
+ * 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
+ */
+export const createFrameCallbackRequest = (callback, frameRate, { subscribeVisibilityChange = subscribeVisibilityChangeEvent, } = {}) => {
+    const props = { callbackId: 0, frameRate, started: false };
+    const getCallbackLoopRunner = (input) => {
+        if (!props.runner) {
+            const fallbackRequestCallback = async (input) => {
+                if (props.runner) {
+                    props.runner.frameRate = getFrameRate(input, props.frameRate);
+                }
+                await callback(input);
+            };
+            props.runner = createAsyncCallbackLoop(fallbackRequestCallback, getFrameRate(input, props.frameRate));
+        }
+        return props.runner;
+    };
+    const cancelFrameCallback = () => {
+        if (hasRequestVideoFrameCallback(props.input) && props.callbackId) {
+            props.input.cancelVideoFrameCallback(props.callbackId);
+            props.callbackId = 0;
+        }
+    };
+    return {
+        start: async (input) => {
+            props.input = input;
+            if (hasRequestVideoFrameCallback(input)) {
+                // Subscribe visibility changes and switch to fallback callback
+                // loop when the page is hidden since the
+                // `requestVideoFrameCallback` is paused when the page is hidden
+                props.unsubscribe = subscribeVisibilityChange(async (hidden) => {
+                    if (props.started && props.input) {
+                        if (hidden && props.callbackId) {
+                            await getCallbackLoopRunner(props.input).start(props.input);
+                        }
+                        else {
+                            getCallbackLoopRunner(props.input).stop();
+                        }
+                    }
+                });
+                await new Promise(resolve => {
+                    const wrap = async () => {
+                        await callback(input);
+                        if (!props.started) {
+                            props.started = true;
+                        }
+                        resolve();
+                        props.callbackId =
+                            input.requestVideoFrameCallback(wrap);
+                    };
+                    props.callbackId = input.requestVideoFrameCallback(wrap);
+                });
+            }
+            else {
+                await getCallbackLoopRunner(input).start(input);
+                props.started = true;
+            }
+        },
+        stop: () => {
+            cancelFrameCallback();
+            props.runner?.stop();
+            props.unsubscribe?.();
+            props.started = false;
+        },
+        get frameRate() {
+            return getFrameRate(props.input, frameRate);
+        },
+        set frameRate(value) {
+            props.frameRate = value;
+            if (props.runner) {
+                props.runner.frameRate = frameRate;
+            }
+        },
+    };
+};

package/dist/main/video/video.d.ts

@@ -0,0 +1,19 @@
+import type { Transform } from '../types';
+import type { InputFrame } from './types';
+import type { ProcessVideoTrack } from './videoStreamTrackProcessor';
+export 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>;
+}
+export declare const createVideoProcessor: (transformers: Array<Transform<InputFrame, InputFrame>>, processTrack: ProcessVideoTrack) => VideoProcessor;

package/dist/main/video/video.js

@@ -0,0 +1,48 @@
+import { stopStreamTracks } from '../utils';
+import { AbortReason } from './constants';
+export const createVideoProcessor = (transformers, processTrack) => {
+    const props = {
+        processing: false,
+    };
+    const open = async () => {
+        await Promise.all(transformers.map(transformer => transformer.init()));
+    };
+    const process = async (source) => {
+        const [track] = source.getVideoTracks();
+        if (!track) {
+            return source;
+        }
+        if (props.processing) {
+            throw new Error('Cannot process when it is already processing');
+        }
+        props.abortController = new AbortController();
+        const trackGenerated = await processTrack(track, transformers, {
+            signal: props.abortController.signal,
+        });
+        props.outputStream = new MediaStream([
+            trackGenerated,
+            ...source.getAudioTracks().map(track => track.clone()),
+        ]);
+        props.processing = true;
+        return props.outputStream;
+    };
+    const close = () => {
+        if (!props.processing) {
+            return;
+        }
+        props.abortController?.abort(AbortReason.Close);
+        stopStreamTracks(props.outputStream);
+        props.outputStream = undefined;
+        props.processing = false;
+    };
+    const destroy = async () => {
+        close();
+        await Promise.all(transformers.map(transformer => transformer.destroy()));
+    };
+    return {
+        open,
+        process,
+        close,
+        destroy,
+    };
+};

package/dist/main/video/videoStreamTrackProcessor.d.ts

@@ -0,0 +1,14 @@
+import type { InputFrame } from './types';
+type Track = MediaStreamVideoTrack | MediaStreamVideoTrackGenerator;
+interface Options {
+    signal?: AbortSignal;
+}
+export type ProcessVideoTrack = (track: MediaStreamVideoTrack, transformers: Array<Transformer<InputFrame, InputFrame>>, options?: Options) => Promise<Track>;
+export declare const createVideoTrackProcessor: () => ProcessVideoTrack;
+interface FallbackOptions {
+    width?: number;
+    height?: number;
+    frameRate?: number;
+}
+export declare const createVideoTrackProcessorWithFallback: ({ width, height, frameRate, }?: FallbackOptions) => ProcessVideoTrack;
+export {};