@pexip/media-processor 20.3.5 → 22.0.0

package/dist/common/backends/webgl/shaders/blendFragmentShader.js

@@ -1,21 +0,0 @@
-export const blendFragmentShaderSource = `#version 300 es
-precision mediump float;
-
-// our textures
-uniform sampler2D u_mask;
-uniform sampler2D u_frame_foreground;
-uniform sampler2D u_frame_background;
-
-in vec2 v_texCoord;
-
-// we need to declare an output for the fragment shader
-out vec4 outColor;
-
-void main() {
-    vec4 background = texture(u_frame_background, v_texCoord);
-    vec4 foreground = texture(u_frame_foreground, v_texCoord);
-    float filteredMask = texture(u_mask, v_texCoord).r;
-
-    outColor = mix(background, foreground, filteredMask);
-}
-`;

package/dist/common/backends/webgl/shaders/dualFilterBlurFragmentShader.d.ts

@@ -1 +0,0 @@
-export declare const dualFilterBlurFragmentShaderSource = "#version 300 es\nprecision mediump float;\n\n// our textures\nuniform sampler2D u_frame;\n\n// control flags\nuniform int u_downsampling;\n\nin vec2 v_texCoord;\n\n// we need to declare an output for the fragment shader\nout vec4 outColor;\n\nvec4 Downsample(sampler2D image, vec2 uv, vec2 halfpixel) {\n    vec4 sum = texture(image, uv) * 4.0;\n    sum += texture(image, uv - halfpixel.xy);\n    sum += texture(image, uv + halfpixel.xy);\n    sum += texture(image, uv + vec2(halfpixel.x, -halfpixel.y));\n    sum += texture(image, uv - vec2(halfpixel.x, -halfpixel.y));\n    return sum / 8.0;\n}\n\nvec4 Upsample(sampler2D image, vec2 uv, vec2 halfpixel) {\n    vec4 sum = texture(image, uv + vec2(-halfpixel.x * 2.0, 0.0));\n    sum += texture(image, uv + vec2(-halfpixel.x, halfpixel.y)) * 2.0;\n    sum += texture(image, uv + vec2(0.0, halfpixel.y * 2.0));\n    sum += texture(image, uv + vec2(halfpixel.x, halfpixel.y)) * 2.0;\n    sum += texture(image, uv + vec2(halfpixel.x * 2.0, 0.0));\n    sum += texture(image, uv + vec2(halfpixel.x, -halfpixel.y)) * 2.0;\n    sum += texture(image, uv + vec2(0.0, -halfpixel.y * 2.0));\n    sum += texture(image, uv + vec2(-halfpixel.x, -halfpixel.y)) * 2.0;\n    return sum / 12.0;\n}\n\nvoid main() {\n    vec2 halfpixel = 0.5 / vec2(textureSize(u_frame, 0));\n\n    if (u_downsampling == 1) {\n        outColor = Downsample(u_frame, v_texCoord, halfpixel);\n        return;\n    }\n    outColor = Upsample(u_frame, v_texCoord, halfpixel);\n}\n";

package/dist/common/backends/webgl/shaders/dualFilterBlurFragmentShader.js

@@ -1,45 +0,0 @@
-export const dualFilterBlurFragmentShaderSource = `#version 300 es
-precision mediump float;
-
-// our textures
-uniform sampler2D u_frame;
-
-// control flags
-uniform int u_downsampling;
-
-in vec2 v_texCoord;
-
-// we need to declare an output for the fragment shader
-out vec4 outColor;
-
-vec4 Downsample(sampler2D image, vec2 uv, vec2 halfpixel) {
-    vec4 sum = texture(image, uv) * 4.0;
-    sum += texture(image, uv - halfpixel.xy);
-    sum += texture(image, uv + halfpixel.xy);
-    sum += texture(image, uv + vec2(halfpixel.x, -halfpixel.y));
-    sum += texture(image, uv - vec2(halfpixel.x, -halfpixel.y));
-    return sum / 8.0;
-}
-
-vec4 Upsample(sampler2D image, vec2 uv, vec2 halfpixel) {
-    vec4 sum = texture(image, uv + vec2(-halfpixel.x * 2.0, 0.0));
-    sum += texture(image, uv + vec2(-halfpixel.x, halfpixel.y)) * 2.0;
-    sum += texture(image, uv + vec2(0.0, halfpixel.y * 2.0));
-    sum += texture(image, uv + vec2(halfpixel.x, halfpixel.y)) * 2.0;
-    sum += texture(image, uv + vec2(halfpixel.x * 2.0, 0.0));
-    sum += texture(image, uv + vec2(halfpixel.x, -halfpixel.y)) * 2.0;
-    sum += texture(image, uv + vec2(0.0, -halfpixel.y * 2.0));
-    sum += texture(image, uv + vec2(-halfpixel.x, -halfpixel.y)) * 2.0;
-    return sum / 12.0;
-}
-
-void main() {
-    vec2 halfpixel = 0.5 / vec2(textureSize(u_frame, 0));
-
-    if (u_downsampling == 1) {
-        outColor = Downsample(u_frame, v_texCoord, halfpixel);
-        return;
-    }
-    outColor = Upsample(u_frame, v_texCoord, halfpixel);
-}
-`;

package/dist/common/backends/webgl/shaders/smoothingMaskFragmentShader.d.ts

@@ -1 +0,0 @@
-export declare const smoothingMaskFragmentShaderSource = "#version 300 es\nprecision mediump float;\n\n// our textures\nuniform sampler2D u_mask;\nuniform sampler2D u_mask_prev;\n\n// control flags\nuniform float u_mask_combine_ratio;\nuniform float u_foreground_threshold;\n\nin vec2 v_texCoord;\n\n// we need to declare an output for the fragment shader\nout vec4 outColor;\n\n// Source: https://github.com/google/mediapipe/blob/8750c3dca1bc00fbe47acf501b7c9c61f3f3bd3f/mediapipe/calculators/image/segmentation_smoothing_calculator.cc#L377\nfloat SmoothingMask(sampler2D prevMask, sampler2D currMask, vec2 uv, float ratio) {\n    float prevMaskValue = texture(prevMask, uv).r;\n    float newMaskValue = texture(currMask, uv).r;\n\n    /*\n    * Assume p := newMaskValue\n    * H(p) := 1 + (p * log(p) + (1-p) * log(1-p)) / log(2)\n    * uncertainty alpha(p) =\n    *   Clamp(1 - (1 - H(p)) * (1 - H(p)), 0, 1) [squaring the\n    * uncertainty]\n    *\n    * The following polynomial approximates uncertainty alpha as a\n    * function of (p + 0.5):\n    */\n    const float c1 = 5.68842;\n    const float c2 = -0.748699;\n    const float c3 = -57.8051;\n    const float c4 = 291.309;\n    const float c5 = -624.717;\n    float t = newMaskValue - 0.5;\n    float x = t * t;\n\n    float uncertainty =\n    1.0 - min(1.0, x * (c1 + x * (c2 + x * (c3 + x * (c4 + x * c5)))));\n\n    float outputValue = newMaskValue + (prevMaskValue - newMaskValue) *\n                            (uncertainty * ratio);\n    return outputValue;\n}\n\nvoid main() {\n    float maskAlpha = SmoothingMask(u_mask_prev, u_mask, v_texCoord, u_mask_combine_ratio);\n    float backgroundMask = maskAlpha;\n    if (backgroundMask < u_foreground_threshold) {\n        backgroundMask = 0.0;\n    }\n\n    outColor = vec4(backgroundMask, backgroundMask, backgroundMask, backgroundMask);\n}\n";

package/dist/common/backends/webgl/shaders/smoothingMaskFragmentShader.js

@@ -1,57 +0,0 @@
-export const smoothingMaskFragmentShaderSource = `#version 300 es
-precision mediump float;
-
-// our textures
-uniform sampler2D u_mask;
-uniform sampler2D u_mask_prev;
-
-// control flags
-uniform float u_mask_combine_ratio;
-uniform float u_foreground_threshold;
-
-in vec2 v_texCoord;
-
-// we need to declare an output for the fragment shader
-out vec4 outColor;
-
-// Source: https://github.com/google/mediapipe/blob/8750c3dca1bc00fbe47acf501b7c9c61f3f3bd3f/mediapipe/calculators/image/segmentation_smoothing_calculator.cc#L377
-float SmoothingMask(sampler2D prevMask, sampler2D currMask, vec2 uv, float ratio) {
-    float prevMaskValue = texture(prevMask, uv).r;
-    float newMaskValue = texture(currMask, uv).r;
-
-    /*
-    * Assume p := newMaskValue
-    * H(p) := 1 + (p * log(p) + (1-p) * log(1-p)) / log(2)
-    * uncertainty alpha(p) =
-    *   Clamp(1 - (1 - H(p)) * (1 - H(p)), 0, 1) [squaring the
-    * uncertainty]
-    *
-    * The following polynomial approximates uncertainty alpha as a
-    * function of (p + 0.5):
-    */
-    const float c1 = 5.68842;
-    const float c2 = -0.748699;
-    const float c3 = -57.8051;
-    const float c4 = 291.309;
-    const float c5 = -624.717;
-    float t = newMaskValue - 0.5;
-    float x = t * t;
-
-    float uncertainty =
-    1.0 - min(1.0, x * (c1 + x * (c2 + x * (c3 + x * (c4 + x * c5)))));
-
-    float outputValue = newMaskValue + (prevMaskValue - newMaskValue) *
-                            (uncertainty * ratio);
-    return outputValue;
-}
-
-void main() {
-    float maskAlpha = SmoothingMask(u_mask_prev, u_mask, v_texCoord, u_mask_combine_ratio);
-    float backgroundMask = maskAlpha;
-    if (backgroundMask < u_foreground_threshold) {
-        backgroundMask = 0.0;
-    }
-
-    outColor = vec4(backgroundMask, backgroundMask, backgroundMask, backgroundMask);
-}
-`;

package/dist/common/backends/webgl/shaders/textureFragmentShader.d.ts

@@ -1 +0,0 @@
-export declare const textureFragmentShaderSource = "#version 300 es\nprecision mediump float;\n\n// Passed in from the vertex shader.\nin vec2 v_texCoord;\n\n// The texture.\nuniform sampler2D u_texture;\n\n// we need to declare an output for the fragment shader\nout vec4 outColor;\n\nvoid main() {\n  outColor = texture(u_texture, v_texCoord);\n}\n";

package/dist/common/backends/webgl/shaders/textureFragmentShader.js

@@ -1,16 +0,0 @@
-export const textureFragmentShaderSource = `#version 300 es
-precision mediump float;
-
-// Passed in from the vertex shader.
-in vec2 v_texCoord;
-
-// The texture.
-uniform sampler2D u_texture;
-
-// we need to declare an output for the fragment shader
-out vec4 outColor;
-
-void main() {
-  outColor = texture(u_texture, v_texCoord);
-}
-`;

package/dist/common/backends/webgl/shaders/vertexShader.d.ts

@@ -1 +0,0 @@
-export declare const vertexShaderSource = "#version 300 es\n// an attribute is an input (in) to a vertex shader.\n// It will receive data from a buffer\nin vec2 a_position;\nin vec2 a_texCoord;\n\n// Used to pass in the resolution of the canvas\nuniform mat3 u_matrix;\n\n// Used to pass the texture coordinates to the fragment shader\nout vec2 v_texCoord;\n\nvoid main() {\n    gl_Position = vec4((u_matrix * vec3(a_position, 1)).xy, 0, 1);\n\n    // pass the texCoord to the fragment shader\n    v_texCoord = a_texCoord;\n}\n";

package/dist/common/backends/webgl/shaders/vertexShader.js

@@ -1,19 +0,0 @@
-export const vertexShaderSource = `#version 300 es
-// an attribute is an input (in) to a vertex shader.
-// It will receive data from a buffer
-in vec2 a_position;
-in vec2 a_texCoord;
-
-// Used to pass in the resolution of the canvas
-uniform mat3 u_matrix;
-
-// Used to pass the texture coordinates to the fragment shader
-out vec2 v_texCoord;
-
-void main() {
-    gl_Position = vec4((u_matrix * vec3(a_position, 1)).xy, 0, 1);
-
-    // pass the texCoord to the fragment shader
-    v_texCoord = a_texCoord;
-}
-`;

package/dist/main/transformer.d.ts

@@ -1 +0,0 @@
-export declare const createStreamTransformer: <I, O>(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>) => TransformStream<I, O>;

package/dist/main/transformer.js

@@ -1,4 +0,0 @@
-export const createStreamTransformer = (transformer, writableStrategy, readableStrategy) => {
-    const transformStream = new TransformStream(transformer, writableStrategy, readableStrategy);
-    return transformStream;
-};

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

@@ -1,17 +0,0 @@
-import type { ImageRecord } from '../../common/types/media';
-import type { RendererOptions } from '../../common/types/render';
-import type { Segmenter, SegmentationTransform } from './types';
-interface Options extends RendererOptions {
-    selfManageSegmenter?: boolean;
-    outputCanvas?: HTMLCanvasElement;
-    outputDelegate?: OffscreenCanvas;
-    backgroundImage?: ImageRecord;
-    width?: number;
-    height?: number;
-}
-export declare const createTransform: (segmenter: Segmenter, { width, height, foregroundThreshold, backgroundBlurAmount, edgeBlurAmount, maskCombineRatio, backgroundImageUrl, effects, backend, selfManageSegmenter, ...options }?: Partial<Options>) => SegmentationTransform & {
-    outputCanvas: HTMLCanvasElement | undefined;
-    outputDelegate: OffscreenCanvas | undefined;
-    backgroundImage?: ImageRecord;
-};
-export {};

package/dist/main/video/canvasTransform.js

@@ -1,253 +0,0 @@
-import { PROCESSING_HEIGHT, PROCESSING_WIDTH, FOREGROUND_THRESHOLD, BACKGROUND_BLUR_AMOUNT, EDGE_BLUR_AMOUNT, MASK_COMBINE_RATIO, } from '../../common/constants';
-import { createCanvasRenderUtils } from '../../common/canvasRenderUtils';
-import { clamping, createObjectUpdater } from '../../common/utils';
-import { assert } from '@pexip/utils';
-const clampInRangeFrom0To1 = clamping(0, 1);
-const clampInRangeFrom0To9 = clamping(0, 9);
-export const createTransform = (segmenter, { width = PROCESSING_WIDTH, height = PROCESSING_HEIGHT, foregroundThreshold = FOREGROUND_THRESHOLD, backgroundBlurAmount = BACKGROUND_BLUR_AMOUNT, edgeBlurAmount = EDGE_BLUR_AMOUNT, maskCombineRatio = MASK_COMBINE_RATIO, backgroundImageUrl = '', effects = 'none', backend = 'webgl', selfManageSegmenter, ...options } = {}) => {
-    const props = {
-        segmenter,
-        processingWidth: width,
-        processingHeight: height,
-        foregroundThreshold,
-        backgroundBlurAmount,
-        edgeBlurAmount,
-        utils: undefined,
-        effects,
-        maskCombineRatio,
-        backgroundImage: options.backgroundImage,
-        status: 'new',
-        backgroundImageUrl,
-        outputCanvas: options.outputCanvas,
-        outputDelegate: options.outputDelegate,
-        backend,
-        unsubscribe: null,
-    };
-    const updateProps = createObjectUpdater(props);
-    const handleContextRestored = () => {
-        assert(props.utils);
-        props.utils.reset();
-    };
-    const toVideoFrameLike = (input) => {
-        // Standardize the input
-        assert(props.utils);
-        const image = input instanceof ImageData
-            ? props.utils.renderImageDataToOffScreenCanvas(input, 'drawImageDataCanvas')
-            : input;
-        // Pre-precessing the input to resize to the processing size
-        const canvas = props.utils.renderImageToOffScreenCanvas(image, 'inputCanvas');
-        if ('close' in input) {
-            input.close();
-        }
-        return {
-            frame: canvas.transferToImageBitmap(),
-            width: props.processingWidth,
-            height: props.processingHeight,
-            timestamp: performance.now(),
-        };
-    };
-    const processInput = async (input) => {
-        const renderOptions = {
-            foregroundThreshold: props.foregroundThreshold,
-            backgroundBlurAmount: props.backgroundBlurAmount,
-            edgeBlurAmount: props.edgeBlurAmount,
-            maskCombineRatio: props.maskCombineRatio,
-            backgroundImageUrl: props.backgroundImageUrl,
-            effects: props.effects,
-            backend: props.backend,
-        };
-        if (props.segmenter.status === 'new' ||
-            props.segmenter.status === 'closed') {
-            await props.segmenter.open({
-                output: props.outputDelegate,
-                processingWidth: props.processingWidth,
-                processingHeight: props.processingHeight,
-                backgroundImage: props.backgroundImage,
-                renderOptions,
-            });
-        }
-        if (!props.utils) {
-            props.utils = createCanvasRenderUtils(props.processingWidth, props.processingHeight);
-        }
-        if (props.segmenter.status === 'opening') {
-            return undefined;
-        }
-        const inputFrame = toVideoFrameLike(input);
-        return props.segmenter.process(inputFrame, renderOptions);
-    };
-    const canUpdate = () => props.segmenter.status !== 'new' &&
-        props.segmenter.status !== 'closed' &&
-        props.segmenter.status !== 'closing';
-    const updateProcessingDimensions = (width, height) => {
-        let newDimensions = false;
-        if (width && props.processingWidth !== width) {
-            props.processingWidth = width;
-            newDimensions = true;
-        }
-        if (height && props.processingHeight !== height) {
-            props.processingHeight = height;
-            newDimensions = true;
-        }
-        if (newDimensions) {
-            props.utils = createCanvasRenderUtils(props.processingWidth, props.processingHeight);
-        }
-    };
-    return {
-        get width() {
-            return props.processingWidth;
-        },
-        get height() {
-            return props.processingHeight;
-        },
-        get status() {
-            return props.status;
-        },
-        get foregroundThreshold() {
-            return props.foregroundThreshold;
-        },
-        get backgroundBlurAmount() {
-            return props.backgroundBlurAmount;
-        },
-        get edgeBlurAmount() {
-            return props.edgeBlurAmount;
-        },
-        get effects() {
-            return props.effects;
-        },
-        get maskCombineRatio() {
-            return props.maskCombineRatio;
-        },
-        get backend() {
-            return props.backend;
-        },
-        set foregroundThreshold(value) {
-            props.foregroundThreshold = clampInRangeFrom0To1(value);
-        },
-        set backgroundBlurAmount(value) {
-            props.backgroundBlurAmount = clampInRangeFrom0To9(value);
-        },
-        set edgeBlurAmount(value) {
-            props.edgeBlurAmount = clampInRangeFrom0To9(value);
-        },
-        set effects(value) {
-            props.effects = value;
-        },
-        set backgroundImageUrl(value) {
-            props.backgroundImageUrl = value;
-        },
-        get backgroundImageUrl() {
-            return props.backgroundImageUrl;
-        },
-        set maskCombineRatio(value) {
-            props.maskCombineRatio = clampInRangeFrom0To1(value);
-        },
-        get outputCanvas() {
-            return props.outputCanvas;
-        },
-        get backgroundImage() {
-            return props.backgroundImage;
-        },
-        set backgroundImage(image) {
-            if (image &&
-                image.key !== props.backgroundImage?.key &&
-                image.image !== props.backgroundImage?.image) {
-                props.backgroundImage = image;
-                if (canUpdate()) {
-                    void props.segmenter.update({ backgroundImage: image });
-                }
-            }
-        },
-        set outputCanvas(canvas) {
-            props.outputCanvas = canvas;
-        },
-        get outputDelegate() {
-            return props.outputDelegate;
-        },
-        set outputDelegate(canvas) {
-            props.outputDelegate = canvas;
-        },
-        get segmenter() {
-            return props.segmenter;
-        },
-        set segmenter(value) {
-            if (value !== props.segmenter) {
-                props.segmenter = value;
-            }
-        },
-        set backend(value) {
-            if (value === props.backend) {
-                return;
-            }
-            props.backend = value;
-            if (canUpdate()) {
-                segmenter.update({
-                    renderOptions: {
-                        backend: props.backend,
-                        backgroundImageUrl: props.backgroundImageUrl,
-                        foregroundThreshold: props.foregroundThreshold,
-                        backgroundBlurAmount: props.backgroundBlurAmount,
-                        edgeBlurAmount: props.edgeBlurAmount,
-                        maskCombineRatio: props.maskCombineRatio,
-                        effects: props.effects,
-                    },
-                });
-            }
-        },
-        init: (options = {}) => {
-            updateProps(options);
-            props.status = 'opened';
-            props.unsubscribe = segmenter.subscribe('ContextRestored', handleContextRestored);
-            return Promise.resolve();
-        },
-        update: async (options) => {
-            updateProcessingDimensions(options.processingWidth, options.processingHeight);
-            // update props needs to happen after dimension comparison
-            updateProps(options);
-            if (canUpdate()) {
-                await segmenter.update(options);
-            }
-        },
-        transform: async (videoFrame, controller) => {
-            switch (props.effects) {
-                case 'overlay':
-                case 'blur': {
-                    const result = await processInput(videoFrame);
-                    const processedFrame = props.outputCanvas ?? result?.frame;
-                    if (props.status === 'closed' ||
-                        // Avoid processing disposed frame
-                        !processedFrame ||
-                        ('displayWidth' in processedFrame &&
-                            processedFrame.displayWidth === 0) ||
-                        ('width' in processedFrame &&
-                            processedFrame.width === 0)) {
-                        break;
-                    }
-                    if ('close' in videoFrame) {
-                        videoFrame.close();
-                    }
-                    controller.enqueue(props.outputCanvas ?? result?.frame);
-                    result?.frame.close();
-                    break;
-                }
-                case 'none': {
-                    controller.enqueue(videoFrame);
-                    break;
-                }
-            }
-            props.status = 'processing';
-        },
-        close: () => {
-            if (!selfManageSegmenter) {
-                segmenter.close();
-            }
-            props.unsubscribe?.();
-            props.status = 'closed';
-        },
-        destroy: async () => {
-            if (!selfManageSegmenter) {
-                await segmenter.destroy();
-            }
-            props.status = 'destroyed';
-        },
-    };
-};

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

@@ -1,22 +0,0 @@
-import type { Segmenter } from '../types';
-import type { Delegate, SegmenterOptions, ImageSegmenterOptions, SegmentationModelAsset } from '../../../common/types/segmentation';
-interface Options extends Omit<ImageSegmenterOptions, 'delegate'> {
-    /**
-     * The URL for the worker script.
-     */
-    workerScriptUrl?: URL;
-    /**
-     * Request Credentials for the worker.
-     *
-     * @defaultValue 'same-origin'
-     */
-    credentials?: RequestCredentials;
-    /**
-     * @see `SegmentationModelAsset`
-     */
-    modelAsset: SegmentationModelAsset;
-    delegate?: () => Delegate;
-    log?: (message: string, meta?: unknown) => void;
-}
-export declare const createSegmenter: (basePath?: SegmenterOptions["basePath"], { workerScriptUrl, credentials, delegate, log, ...options }?: Options) => Segmenter;
-export {};

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

@@ -1,9 +0,0 @@
-import type { InputFrame } from './types';
-export declare const nullTransformController: (controller: Pick<TransformStreamDefaultController<CanvasImageSource>, "enqueue" | "terminate">) => TransformStreamDefaultController<CanvasImageSource>;
-export declare const adaptInputFrameTransformer: (transformer: Transformer<InputFrame, InputFrame>) => {
-    transform: (frame: VideoFrame, controller: TransformStreamDefaultController<VideoFrame>) => void | PromiseLike<void> | undefined;
-    flush?: TransformerFlushCallback<InputFrame> | undefined;
-    readableType?: undefined;
-    start?: TransformerStartCallback<InputFrame> | undefined;
-    writableType?: undefined;
-};

package/dist/main/video/transformer.js

@@ -1,68 +0,0 @@
-const wrapTransformController = (videoFrame, controller) => {
-    return {
-        get desiredSize() {
-            return controller.desiredSize;
-        },
-        enqueue: frame => {
-            if (!frame) {
-                return;
-            }
-            if (frame instanceof VideoFrame) {
-                return controller.enqueue(frame);
-            }
-            if (('OffscreenCanvas' in window &&
-                frame instanceof OffscreenCanvas) ||
-                frame instanceof HTMLCanvasElement ||
-                frame instanceof HTMLVideoElement ||
-                frame instanceof HTMLImageElement ||
-                frame instanceof ImageBitmap) {
-                const timestamp = videoFrame.timestamp ?? 0;
-                try {
-                    // Constructing a new VideoFrame with the modified frame
-                    // could throw an error
-                    const newFrame = new VideoFrame(frame, {
-                        timestamp,
-                        alpha: 'discard',
-                    });
-                    controller.enqueue(newFrame);
-                    videoFrame.close();
-                }
-                catch {
-                    controller.enqueue(videoFrame);
-                }
-                return;
-            }
-            throw new Error('Unexpected input frame');
-        },
-        error: reason => controller.error(reason),
-        terminate: () => controller.terminate(),
-    };
-};
-export const nullTransformController = (controller) => {
-    return {
-        get desiredSize() {
-            return 0;
-        },
-        enqueue: frame => {
-            if (('OffscreenCanvas' in window &&
-                frame instanceof OffscreenCanvas) ||
-                frame instanceof HTMLCanvasElement ||
-                frame instanceof HTMLVideoElement ||
-                frame instanceof HTMLImageElement ||
-                frame instanceof ImageBitmap) {
-                return controller.enqueue(frame);
-            }
-            throw new Error('Unexpected input frame');
-        },
-        error: reason => {
-            throw new Error(reason);
-        },
-        terminate: () => controller.terminate(),
-    };
-};
-export const adaptInputFrameTransformer = (transformer) => {
-    const transform = (frame, controller) => {
-        return transformer.transform?.(frame, wrapTransformController(frame, controller));
-    };
-    return { ...transformer, transform };
-};

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

@@ -1,20 +0,0 @@
-import type { InputFrame } from './types';
-type Track = MediaStreamVideoTrack | MediaStreamVideoTrackGenerator;
-interface Options {
-    signal?: AbortSignal;
-}
-export type ProcessVideoTrack = (track: MediaStreamVideoTrack, transformers: Transformer<InputFrame, InputFrame>[], options?: Options) => Promise<Track>;
-/**
- * Video track processor using MediaStreamTrackProcessor API
- */
-export declare const createVideoTrackProcessor: () => ProcessVideoTrack;
-interface FallbackOptions {
-    width?: number;
-    height?: number;
-    frameRate?: number;
-}
-/**
- * Video track processor using Canvas[captureStream] API
- */
-export declare const createVideoTrackProcessorWithFallback: ({ width, height, frameRate, }?: FallbackOptions) => ProcessVideoTrack;
-export {};

package/dist/main/video/videoStreamTrackProcessor.js

@@ -1,86 +0,0 @@
-import { assert } from '@pexip/utils';
-import { createMediaStreamTrackProcessor } from '../processor';
-import { createMediaStreamTrackGenerator } from '../generator';
-import { createStreamTransformer } from '../transformer';
-import { stopStreamTracks } from '../utils';
-import { PROCESSING_HEIGHT, PROCESSING_WIDTH } from '../../common/constants';
-import { getImageSize } from '../../common/canvasRenderUtils';
-import { adaptInputFrameTransformer, nullTransformController, } from './transformer';
-import { toVideoElement, playVideo, createFrameCallbackRequest, createCanvas, getCanvasRenderingContext2D, } from './utils';
-import { AbortReason, FRAME_RATE } from './constants';
-/**
- * Video track processor using MediaStreamTrackProcessor API
- */
-export const createVideoTrackProcessor = () => (track, transformers, { signal } = {}) => {
-    if (!transformers.length) {
-        return Promise.resolve(track);
-    }
-    const processor = createMediaStreamTrackProcessor({ track });
-    const trackGenerator = createMediaStreamTrackGenerator({ kind: 'video' });
-    let readable = processor.readable;
-    for (const transformer of transformers) {
-        readable = readable.pipeThrough(createStreamTransformer(adaptInputFrameTransformer(transformer)), { signal });
-    }
-    // Promise returned from `ReadableStream['pipeTo']` is only resolved
-    // when the streaming is finished
-    readable
-        .pipeTo(trackGenerator.writable, {
-        signal,
-    })
-        .catch(error => {
-        // Ignore abort error
-        if (signal &&
-            !(signal.aborted &&
-                (signal.reason === AbortReason.Close ||
-                    // AbortSignal['reason'] is only supported from Chromium v98 or Firefox v97
-                    !('reason' in AbortSignal.prototype)))) {
-            throw error;
-        }
-    });
-    return Promise.resolve(trackGenerator);
-};
-/**
- * Video track processor using Canvas[captureStream] API
- */
-export const createVideoTrackProcessorWithFallback = ({ width = PROCESSING_WIDTH, height = PROCESSING_HEIGHT, frameRate = FRAME_RATE, } = {}) => async (track, transformers, { signal } = {}) => {
-    const [transformer] = transformers;
-    if (!transformer?.transform) {
-        return track;
-    }
-    assert(transformers.length <= 1, 'Multi-transformer is NOT supported');
-    const outputCanvas = createCanvas(width, height);
-    const ctx = getCanvasRenderingContext2D(outputCanvas, { alpha: false });
-    const render = (input) => {
-        assert(transformer.transform);
-        return Promise.resolve(transformer.transform(input, nullTransformController({
-            enqueue: frame => {
-                if (!frame) {
-                    return;
-                }
-                const frameSize = getImageSize(frame);
-                if (frameSize.height !== outputCanvas.height ||
-                    frameSize.width !== outputCanvas.width) {
-                    outputCanvas.height = frameSize.height;
-                    outputCanvas.width = frameSize.width;
-                }
-                ctx.drawImage(frame, 0, 0, outputCanvas.width, outputCanvas.height);
-            },
-            terminate: () => {
-                stop();
-            },
-        })));
-    };
-    const runner = createFrameCallbackRequest(render, frameRate);
-    const videoElement = toVideoElement(new MediaStream([track]), width, height);
-    await playVideo(videoElement);
-    await runner.start(videoElement);
-    const stream = outputCanvas.captureStream(frameRate);
-    const [trackGenerated] = stream.getVideoTracks();
-    assert(trackGenerated, 'Canvas captureStream returns no video track');
-    const stop = () => {
-        stopStreamTracks(stream);
-        runner.stop();
-    };
-    signal?.addEventListener('abort', stop);
-    return trackGenerated;
-};