@pexip/media-processor 18.5.0 → 19.1.0

package/CHANGELOG.md

@@ -1,5 +1,54 @@
 # Changelog
 
+## 19.1.0
+
+### Minor Changes
+
+- e3a9d84: Update mediapipe and related asset to v0.10.20
+
+## 19.0.0
+
+### Minor Changes
+
+- 5b9daa4: Update @mediapipe/tasks-vision to 0.10.17
+- 164a3e2: extract assert function
+- 4fd97b2: Handle WebGL ContextLost & ContextRestored events
+
+  There is no way we could avoid context lost and we should have a robust
+  context lost handling in-place.
+
+  The following changes have been made:
+
+  - Handle WebGL context lost and restore events
+  - Dispatch custom event messages from WebWorker to Main thread
+  - Add debug capabilities to segmenter
+  - Allow Process Worker to restart processing
+  - Add reset() function to canvasRenderUtils
+  - Handle failed to create VideoFrame during the context lost
+  - Make Renderer stateless and Process Worker stateful
+  - Add restart function to Process Worker
+  - Ensure there is no processing when error occurs
+  - Workaround 2D Canvas context lost event bug
+    https://issues.chromium.org/issues/372756071
+
+  Related issues:
+
+  - Closes https://github.com/pexip/mcu/issues/39045
+  - Closes https://gitlab.com/pexip/zoo/-/issues/4896
+
+  Reference https://toji.dev/webgpu-best-practices/device-loss.html
+
+- db258ca: Bump @mediapipe/task-visions to v0.10.18
+- dfd1900: Timeout play video
+
+### Patch Changes
+
+- 22a807b: Fix multi-trnasformer assertion
+- Updated dependencies [164a3e2]
+- Updated dependencies [b13010c]
+- Updated dependencies [66a8f72]
+  - @pexip/utils@16.13.0
+
 ## 18.5.0
 
 ### Minor Changes

package/dist/common/backends/webgl/blender.js

@@ -1,4 +1,5 @@
-import { assert } from '../../utils';
+import { assert } from '@pexip/utils';
+import { RENDERING_EVENTS } from '../../constants';
 import { m3 } from '../../m3';
 import { createGLProgram, createAndSetupTexture } from './webglUtils';
 import { vertexShaderSource } from './shaders/vertexShader';
@@ -61,6 +62,7 @@ export const createBlendRenderer = (processor) => {
     gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, outputTexture, 0);
     return {
         render: ({ mask, foreground, background, }) => {
+            assert(!gl.isContextLost(), RENDERING_EVENTS.ContextLost);
             gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer);
             gl.viewport(0, 0, processor.width, processor.height);
             gl.useProgram(program);

package/dist/common/backends/webgl/blur.js

@@ -1,4 +1,6 @@
-import { assert, clamping } from '../../utils';
+import { assert } from '@pexip/utils';
+import { clamping } from '../../utils';
+import { RENDERING_EVENTS } from '../../constants';
 import { m3 } from '../../m3';
 import { createAndSetupTexture, createGLProgram } from './webglUtils';
 import { vertexShaderSource } from './shaders/vertexShader';
@@ -84,6 +86,7 @@ export const createBlurRenderer = (processor, pass) => {
     const blurBuffers = generateBlurBuffers(pass + 1);
     return {
         render: (frame, pass) => {
+            assert(!gl.isContextLost(), RENDERING_EVENTS.ContextLost);
             gl.useProgram(program);
             gl.bindVertexArray(vao);
             // Frame texture
@@ -112,8 +115,14 @@ export const createBlurRenderer = (processor, pass) => {
                 gl.uniformMatrix3fv(uniformLocations.matrix, false, matrix);
                 gl.drawArrays(gl.TRIANGLES, 0, 6);
                 const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
-                if (status !== gl.FRAMEBUFFER_COMPLETE) {
-                    throw new Error(`downsampling FrameBuffer Status: ${status}`);
+                const error = gl.getError();
+                assert(error !== gl.CONTEXT_LOST_WEBGL, RENDERING_EVENTS.ContextLost);
+                assert(!gl.isContextLost(), RENDERING_EVENTS.ContextLost);
+                if (status !== gl.FRAMEBUFFER_COMPLETE ||
+                    error !== gl.NO_ERROR) {
+                    throw new Error(RENDERING_EVENTS.SamplingError, {
+                        cause: `downsampling FrameBuffer Status: ${status}`,
+                    });
                 }
                 // for the next draw, use the texture we just rendered to.
                 gl.bindTexture(gl.TEXTURE_2D, texture);
@@ -130,8 +139,14 @@ export const createBlurRenderer = (processor, pass) => {
                 gl.uniformMatrix3fv(uniformLocations.matrix, false, matrix);
                 gl.drawArrays(gl.TRIANGLES, 0, 6);
                 const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
-                if (status !== gl.FRAMEBUFFER_COMPLETE) {
-                    throw new Error(`Upsampling FrameBuffer Status: ${status}`);
+                const error = gl.getError();
+                assert(error !== gl.CONTEXT_LOST_WEBGL, RENDERING_EVENTS.ContextLost);
+                assert(!gl.isContextLost(), RENDERING_EVENTS.ContextLost);
+                if (status !== gl.FRAMEBUFFER_COMPLETE ||
+                    error !== gl.NO_ERROR) {
+                    throw new Error(RENDERING_EVENTS.SamplingError, {
+                        cause: `Upsampling FrameBuffer Status: ${status}`,
+                    });
                 }
                 // for the next draw, use the texture we just rendered to.
                 gl.bindTexture(gl.TEXTURE_2D, texture);

package/dist/common/backends/webgl/canvas.js

@@ -1,4 +1,6 @@
+import { assert } from '@pexip/utils';
 import { m3 } from '../../m3';
+import { RENDERING_EVENTS } from '../../constants';
 import { createGLProgram } from './webglUtils';
 import { vertexShaderSource } from './shaders/vertexShader';
 import { textureFragmentShaderSource } from './shaders/textureFragmentShader';
@@ -53,6 +55,7 @@ export const createCanvasRenderer = (processor) => {
     gl.vertexAttribPointer(attribLocations.texCoord, 2, gl.FLOAT, false, 0, 0);
     return {
         render: (texture) => {
+            assert(!gl.isContextLost(), RENDERING_EVENTS.ContextLost);
             // Draw on the Canvas
             gl.bindFramebuffer(gl.FRAMEBUFFER, null);
             gl.viewport(0, 0, processor.width, processor.height);

package/dist/common/backends/webgl/renderer.d.ts

@@ -1,8 +1,2 @@
-import type { Renderer, RendererOptions } from '../../types/render';
-import type { ImageMapIterable } from '../../types/media';
-interface Options extends Partial<RendererOptions> {
-    backgroundImageInits?: ImageMapIterable;
-    onError?: (error: Error) => void;
-}
-export declare const createRenderer: (canvas?: OffscreenCanvas, { backgroundBlurAmount, backgroundImageUrl, edgeBlurAmount, effects, foregroundThreshold, maskCombineRatio, onError, backgroundImageInits, }?: Options) => Renderer;
-export {};
+import type { Renderer, RenderEventHandlers } from '../../types/render';
+export declare const createRenderer: (canvas: OffscreenCanvas | undefined, renderEventHandlers: RenderEventHandlers) => Renderer;

package/dist/common/backends/webgl/renderer.js

@@ -1,5 +1,5 @@
-import { PROCESSING_WIDTH, PROCESSING_HEIGHT, EDGE_BLUR_AMOUNT, BACKGROUND_BLUR_AMOUNT, FOREGROUND_THRESHOLD, MASK_COMBINE_RATIO, RENDER_EFFECT, } from '../../constants';
-import { createObjectUpdater, createRemoteImageBitmap } from '../../utils';
+import { assert } from '@pexip/utils';
+import { PROCESSING_WIDTH, PROCESSING_HEIGHT, EDGE_BLUR_AMOUNT, BACKGROUND_BLUR_AMOUNT, RENDERING_EVENTS, } from '../../constants';
 import { toTextureInfo } from './webglUtils';
 import { createTextureRenderer } from './texture';
 import { createBlurRenderer } from './blur';
@@ -19,14 +19,14 @@ const createLazyProps = (stateBuilder) => {
         },
     });
 };
-export const createRenderer = (canvas = new OffscreenCanvas(PROCESSING_WIDTH, PROCESSING_HEIGHT), { backgroundBlurAmount = BACKGROUND_BLUR_AMOUNT, backgroundImageUrl = '', edgeBlurAmount = EDGE_BLUR_AMOUNT, effects = RENDER_EFFECT.None, foregroundThreshold = FOREGROUND_THRESHOLD, maskCombineRatio = MASK_COMBINE_RATIO, onError, backgroundImageInits, } = {}) => {
+export const createRenderer = (canvas = new OffscreenCanvas(PROCESSING_WIDTH, PROCESSING_HEIGHT), renderEventHandlers) => {
     const rendererCreator = {
         videoFrameRenderer: () => createTextureRenderer(canvas),
         canvasRenderer: () => createCanvasRenderer(canvas),
         backgroundImageRenderer: () => createTextureRenderer(canvas),
         blendRenderer: () => createBlendRenderer(canvas),
-        blurRenderer: () => createBlurRenderer(canvas, props.backgroundBlurAmount),
-        maskBlurRenderer: () => createBlurRenderer(canvas, props.edgeBlurAmount),
+        blurRenderer: () => createBlurRenderer(canvas, BACKGROUND_BLUR_AMOUNT),
+        maskBlurRenderer: () => createBlurRenderer(canvas, EDGE_BLUR_AMOUNT),
         textureRenderer: () => createTextureToTextureRenderer(canvas),
         smoothingMaskRenderer: () => createSmoothingMaskRenderer(canvas),
         release: (states) => () => Object.keys(states).forEach(key => key !== 'release' &&
@@ -34,14 +34,8 @@ export const createRenderer = (canvas = new OffscreenCanvas(PROCESSING_WIDTH, PR
     };
     let lazyProps = createLazyProps(rendererCreator);
     const props = {
-        backgroundBlurAmount,
-        backgroundImageUrl,
-        edgeBlurAmount,
-        effects,
-        foregroundThreshold,
-        maskCombineRatio,
         canvas,
-        backgroundImages: createRemoteImageBitmap(backgroundImageInits),
+        gl: null,
         // TODO: refactor to avoid repeated codes
         get videoFrameRenderer() {
             return lazyProps.videoFrameRenderer;
@@ -69,55 +63,45 @@ export const createRenderer = (canvas = new OffscreenCanvas(PROCESSING_WIDTH, PR
             return lazyProps.smoothingMaskRenderer;
         },
     };
-    const updateProps = createObjectUpdater(props);
-    const update = options => {
-        if (options.backgroundImage) {
-            props.backgroundImages.setImage(options.backgroundImage.key, options.backgroundImage.image);
-        }
-        updateProps(options);
+    const handleContextLost = (event) => {
+        event.preventDefault();
+        cleanup();
+        renderEventHandlers.contextLost(event.statusMessage);
     };
-    const handleError = (error) => {
-        if (error instanceof Error) {
-            return onError?.(error);
-        }
-        throw error;
+    const handleContextRestored = (event) => {
+        renderEventHandlers.contextRestored(event.statusMessage);
     };
-    const init = options => {
-        if (options) {
-            update(options);
-        }
+    const handleContextCreationError = (event) => {
+        renderEventHandlers.contextCreationError(event.statusMessage);
+    };
+    const init = () => {
+        canvas.addEventListener('webglcontextlost', handleContextLost);
+        canvas.addEventListener('webglcontextrestored', handleContextRestored);
+        canvas.addEventListener('webglcontextcreationerror', handleContextCreationError);
+        props.gl = canvas.getContext('webgl2', {
+            premultipliedAlpha: false,
+            powerPreference: 'high-performance',
+        });
+        assert(props.gl, RENDERING_EVENTS.ContextCreationError);
     };
     const render = (mask, frame, options) => {
-        if (options) {
-            updateProps(options);
-        }
+        assert(!props.gl?.isContextLost(), RENDERING_EVENTS.ContextLost);
         const smoothedMask = props.smoothingMaskRenderer.render({
             mask: toTextureInfo(mask),
             prevMask: props.prevMask,
-        }, props);
+        }, options);
         const frameTexture = props.videoFrameRenderer.render(frame);
         let background = frameTexture;
-        if (props.effects === 'blur' && props.backgroundBlurAmount) {
-            background = props.blurRenderer.render(frameTexture, props.backgroundBlurAmount);
+        if (options.effects === 'blur' && options.backgroundBlurAmount) {
+            background = props.blurRenderer.render(frameTexture, options.backgroundBlurAmount);
         }
-        else if (props?.effects === 'overlay' && props.backgroundImageUrl) {
-            // Keep rendering with video frame until we get the background image
-            const backgroundImage = props.backgroundImages.getImage(props.backgroundImageUrl);
-            if (backgroundImage) {
-                background = props.backgroundImageRenderer.render({
-                    frame: backgroundImage,
-                    timestamp: performance.now(),
-                    width: backgroundImage.width,
-                    height: backgroundImage.height,
-                });
-            }
-            else {
-                props.backgroundImages
-                    .tryFetchingImage(props.backgroundImageUrl)
-                    .catch(error => {
-                    handleError(new Error(`FailedToLoadBackgroundImage: ${props.backgroundImageUrl}`, { cause: error }));
-                });
-            }
+        else if (options?.effects === 'overlay' && options.backgroundImage) {
+            background = props.backgroundImageRenderer.render({
+                frame: options.backgroundImage,
+                timestamp: performance.now(),
+                width: options.backgroundImage.width,
+                height: options.backgroundImage.height,
+            });
         }
         const blendedFrameTexture = props.blendRenderer.render({
             mask: smoothedMask,
@@ -128,11 +112,19 @@ export const createRenderer = (canvas = new OffscreenCanvas(PROCESSING_WIDTH, PR
         // Cloned the current smoothedMask so it can be fed back to the next round
         props.prevMask = props.textureRenderer.render(smoothedMask);
     };
-    const release = () => {
+    const cleanup = () => {
         lazyProps.release();
         lazyProps = createLazyProps(rendererCreator);
-        props.backgroundImages.clear();
         props.prevMask = undefined;
     };
-    return { init, render, release, update };
+    const release = () => {
+        canvas.removeEventListener('webglcontextlost', handleContextLost);
+        canvas.removeEventListener('webglcontextrestored', handleContextRestored);
+        canvas.removeEventListener('webglcontextcreationerror', handleContextCreationError);
+        cleanup();
+    };
+    const isContextLost = () => {
+        return !!props.gl?.isContextLost();
+    };
+    return { init, render, release, isContextLost };
 };

package/dist/common/backends/webgl/smoothingMask.js

@@ -1,5 +1,6 @@
-import { assert } from '../../utils';
+import { assert } from '@pexip/utils';
 import { m3 } from '../../m3';
+import { RENDERING_EVENTS } from '../../constants';
 import { createGLProgram, createAndSetupTexture } from './webglUtils';
 import { vertexShaderSource } from './shaders/vertexShader';
 import { smoothingMaskFragmentShaderSource } from './shaders/smoothingMaskFragmentShader';
@@ -61,6 +62,7 @@ export const createSmoothingMaskRenderer = (processor) => {
     gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, outputTexture, 0);
     return {
         render: ({ mask, prevMask, }, options) => {
+            assert(!gl.isContextLost(), RENDERING_EVENTS.ContextLost);
             gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer);
             gl.viewport(0, 0, processor.width, processor.height);
             gl.clearColor(0, 0, 0, 0);

package/dist/common/backends/webgl/texture.js

@@ -1,4 +1,5 @@
-import { assert } from '../../utils';
+import { assert } from '@pexip/utils';
+import { RENDERING_EVENTS } from '../../constants';
 import { m3 } from '../../m3';
 import { createAndSetupTexture, createGLProgram } from './webglUtils';
 import { vertexShaderSource } from './shaders/vertexShader';
@@ -60,6 +61,7 @@ export const createTextureRenderer = (processor) => {
     gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, outputTexture, 0);
     return {
         render: (video) => {
+            assert(!gl.isContextLost(), RENDERING_EVENTS.ContextLost);
             // Draw on the frame buffer
             gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer);
             gl.viewport(0, 0, processor.width, processor.height);

package/dist/common/backends/webgl/textureToTexture.js

@@ -1,4 +1,5 @@
-import { assert } from '../../utils';
+import { assert } from '@pexip/utils';
+import { RENDERING_EVENTS } from '../../constants';
 import { m3 } from '../../m3';
 import { createAndSetupTexture, createGLProgram } from './webglUtils';
 import { vertexShaderSource } from './shaders/vertexShader';
@@ -59,6 +60,7 @@ export const createTextureToTextureRenderer = (processor) => {
     gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, outputTexture, 0);
     return {
         render: (inputTexture) => {
+            assert(!gl.isContextLost(), RENDERING_EVENTS.ContextLost);
             // Draw on the frame buffer
             gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer);
             gl.viewport(0, 0, processor.width, processor.height);

package/dist/common/backends/webgl/webglUtils.js

@@ -166,6 +166,7 @@ export const getLocations = (gl, program, locations) => Object.keys(locations).r
 export const createGLProgram = (processCanvas, { attribs, uniforms, vertexSrc, fragmentSrc, }) => {
     const gl = processCanvas.getContext('webgl2', {
         premultipliedAlpha: false,
+        powerPreference: 'high-performance',
     });
     if (!gl) {
         throw new Error('WebGL2 is not supported');

package/dist/common/canvasRenderUtils.d.ts

@@ -1,13 +1,17 @@
 import type { Segmentation } from './types/media';
-interface InternalCanvases {
-    drawImageDataCanvas?: OffscreenCanvas;
-    maskCanvas?: OffscreenCanvas;
-    blurredMaskCanvas?: OffscreenCanvas;
-    blurredCanvas?: OffscreenCanvas;
-    downScaledCanvas?: OffscreenCanvas;
-    backgroundImageCanvas?: OffscreenCanvas;
-    inputCanvas?: OffscreenCanvas;
-}
+declare const INTERNAL_CANVAS_KEYS: {
+    readonly drawImageDataCanvas: "drawImageDataCanvas";
+    readonly maskCanvas: "maskCanvas";
+    readonly blurredMaskCanvas: "blurredMaskCanvas";
+    readonly blurredCanvas: "blurredCanvas";
+    readonly downScaledCanvas: "downScaledCanvas";
+    readonly backgroundImageCanvas: "backgroundImageCanvas";
+    readonly inputCanvas: "inputCanvas";
+};
+type InternalCanvasKeys = keyof typeof INTERNAL_CANVAS_KEYS;
+type InternalCanvases = {
+    [key in InternalCanvasKeys]?: OffscreenCanvas;
+};
 export interface Point {
     x: number;
     y: number;
@@ -58,5 +62,6 @@ export declare const createCanvasRenderUtils: (processingWidth: number, processi
         offscreenCanvasName: keyof InternalCanvases;
         preserveOldDrawing?: boolean | undefined;
     }) => OffscreenCanvas;
+    reset: () => void;
 };
 export {};

package/dist/common/canvasRenderUtils.js

@@ -1,4 +1,13 @@
 import { resize } from './utils';
+const INTERNAL_CANVAS_KEYS = {
+    drawImageDataCanvas: 'drawImageDataCanvas',
+    maskCanvas: 'maskCanvas',
+    blurredMaskCanvas: 'blurredMaskCanvas',
+    blurredCanvas: 'blurredCanvas',
+    downScaledCanvas: 'downScaledCanvas',
+    backgroundImageCanvas: 'backgroundImageCanvas',
+    inputCanvas: 'inputCanvas',
+};
 export const getCanvasRenderingContext2D = (canvas, options) => {
     const context = canvas.getContext('2d', options);
     if (!context) {
@@ -67,14 +76,15 @@ export const createCanvasRenderUtils = (processingWidth, processingHeight) => {
     const props = {
         downScaleFactor: 3,
     };
+    const createInternalCanvas = (canvasName) => createOffscreenCanvas(canvasName === 'downScaledCanvas'
+        ? Math.trunc(processingWidth / props.downScaleFactor)
+        : processingWidth, canvasName === 'downScaledCanvas'
+        ? Math.trunc(processingHeight / props.downScaleFactor)
+        : processingHeight);
     const getCanvas = (canvasName) => {
         const canvas = props[canvasName];
         if (!canvas) {
-            const canvas = createOffscreenCanvas(canvasName === 'downScaledCanvas'
-                ? Math.trunc(processingWidth / props.downScaleFactor)
-                : processingWidth, canvasName === 'downScaledCanvas'
-                ? Math.trunc(processingHeight / props.downScaleFactor)
-                : processingHeight);
+            const canvas = createInternalCanvas(canvasName);
             props[canvasName] = canvas;
             return canvas;
         }
@@ -256,5 +266,16 @@ export const createCanvasRenderUtils = (processingWidth, processingHeight) => {
         renderImageToOffScreenCanvas,
         renderImageDataToOffScreenCanvas,
         drawAndBlurImageOnOffScreenCanvas,
+        reset: () => {
+            Object.keys(INTERNAL_CANVAS_KEYS).forEach(key => {
+                const canvasKey = key;
+                const canvas = props[canvasKey];
+                if (canvas && canvas instanceof OffscreenCanvas) {
+                    // Reset Canvas by creating a new one as it is more reliable
+                    // than setting the width and height to 0 in the situation of context lost
+                    props[canvasKey] = createInternalCanvas(canvasKey);
+                }
+            });
+        },
     };
 };

package/dist/common/constants.d.ts

@@ -5,17 +5,22 @@ export declare const FOREGROUND_THRESHOLD = 0.5;
 export declare const BACKGROUND_BLUR_AMOUNT = 3;
 export declare const EDGE_BLUR_AMOUNT = 3;
 export declare const MASK_COMBINE_RATIO = 0.5;
+/**
+ * Process status
+ */
 export declare const PROCESS_STATUS: {
-    readonly New: "new";
+    readonly Closed: "closed";
+    readonly Closing: "closing";
+    readonly Destroyed: "destroyed";
+    readonly Destroying: "destroying";
     readonly Error: "Error";
+    readonly Idle: "idle";
+    readonly New: "new";
     readonly Opened: "opened";
     readonly Opening: "opening";
     readonly Processing: "processing";
-    readonly Idle: "idle";
-    readonly Closing: "closing";
-    readonly Closed: "closed";
-    readonly Destroying: "destroying";
-    readonly Destroyed: "destroyed";
+    readonly Updated: "updated";
+    readonly Updating: "updating";
 };
 export type ProcessStatus = ExtractValueTypes<typeof PROCESS_STATUS>;
 export declare const RENDER_EFFECT: {
@@ -24,4 +29,31 @@ export declare const RENDER_EFFECT: {
     readonly Overlay: "overlay";
 };
 export type RenderEffects = ExtractValueTypes<typeof RENDER_EFFECT>;
+export declare const RENDERING_EVENTS: {
+    /**
+     * Triggered when failed to create a context
+     */
+    readonly ContextCreationError: "ContextCreationError";
+    /**
+     * Triggered when context is lost
+     */
+    readonly ContextLost: "ContextLost";
+    /**
+     * Triggered when context is restored
+     */
+    readonly ContextRestored: "ContextRestored";
+    /**
+     * Triggered when there is unknown error
+     */
+    readonly Error: "Error";
+    /**
+     * Triggered when the processor is restarted
+     */
+    readonly ProcessorRestarted: "ProcessorRestarted";
+    /**
+     * Triggered when sampling error occurs
+     */
+    readonly SamplingError: "SamplingError";
+};
+export type RenderingEvents = ExtractValueTypes<typeof RENDERING_EVENTS>;
 export {};

package/dist/common/constants.js

@@ -4,20 +4,51 @@ export const FOREGROUND_THRESHOLD = 0.5;
 export const BACKGROUND_BLUR_AMOUNT = 3; // Between 1 and 20
 export const EDGE_BLUR_AMOUNT = 3; // Between 0 and 20
 export const MASK_COMBINE_RATIO = 0.5;
+/**
+ * Process status
+ */
 export const PROCESS_STATUS = {
-    New: 'new',
+    Closed: 'closed',
+    Closing: 'closing',
+    Destroyed: 'destroyed',
+    Destroying: 'destroying',
     Error: 'Error',
+    Idle: 'idle',
+    New: 'new',
     Opened: 'opened',
     Opening: 'opening',
     Processing: 'processing',
-    Idle: 'idle',
-    Closing: 'closing',
-    Closed: 'closed',
-    Destroying: 'destroying',
-    Destroyed: 'destroyed',
+    Updated: 'updated',
+    Updating: 'updating',
 };
 export const RENDER_EFFECT = {
     None: 'none',
     Blur: 'blur',
     Overlay: 'overlay',
 };
+export const RENDERING_EVENTS = {
+    /**
+     * Triggered when failed to create a context
+     */
+    ContextCreationError: 'ContextCreationError',
+    /**
+     * Triggered when context is lost
+     */
+    ContextLost: 'ContextLost',
+    /**
+     * Triggered when context is restored
+     */
+    ContextRestored: 'ContextRestored',
+    /**
+     * Triggered when there is unknown error
+     */
+    Error: 'Error',
+    /**
+     * Triggered when the processor is restarted
+     */
+    ProcessorRestarted: 'ProcessorRestarted',
+    /**
+     * Triggered when sampling error occurs
+     */
+    SamplingError: 'SamplingError',
+};