@pexip/media-processor 22.0.0 → 22.1.0

package/dist/main/video/segmenter.js

@@ -21,17 +21,31 @@ basePath = '/', { workerScriptUrl = new URL('../../workers/mediaWorker.js', impo
             credentials,
         });
         mediaWorker.addEventListener('error', error => {
-            log?.(`${error.message}`, error);
+            log?.error({ event: error, error: error.error }, `${error.message}`);
             error.preventDefault();
         });
         mediaWorker.addEventListener('message', (event) => {
             switch (event.data.type) {
                 case 'debug': {
-                    log?.(event.data.data.message, event.data.data.context);
+                    log?.debug(event.data.data.context, event.data.data.message);
                     break;
                 }
                 case 'event': {
-                    log?.(event.data.data.type, event.data.data.message);
+                    switch (event.data.data.type) {
+                        case 'Error':
+                        case 'ContextCreationError':
+                        case 'SamplingError':
+                            log?.error(event.data.data, event.data.data.message);
+                            break;
+                        case 'ContextLost':
+                        case 'ContextRestored':
+                        case 'ProcessorRestarted':
+                            log?.info(event.data.data, event.data.data.message);
+                            break;
+                        default:
+                            log?.debug(event.data.data, event.data.data.message);
+                            break;
+                    }
                     for (const cb of props.eventHandlers.get(event.data.data.type) ?? []) {
                         cb();
                     }
@@ -72,9 +86,7 @@ basePath = '/', { workerScriptUrl = new URL('../../workers/mediaWorker.js', impo
             }
         }
         catch (err) {
-            log?.('Failed to restart process', {
-                error: err,
-            });
+            log?.error({ error: err }, 'Failed to restart process');
             props.status = PROCESS_STATUS.Error;
         }
     };
@@ -100,20 +112,26 @@ basePath = '/', { workerScriptUrl = new URL('../../workers/mediaWorker.js', impo
                     }
                     case 'event': {
                         removeListener();
-                        reject(new Error(ev.data.data.type, {
-                            cause: ev.data.data.message,
-                        }));
+                        reject(ev.data.data.error ??
+                            new Error(ev.data.data.type, {
+                                cause: ev.data.data.message,
+                            }));
                         break;
                     }
                     default: {
-                        removeListener();
-                        reject(new Error(`UnhandledEvent: ${ev.data.type}`));
+                        // Ignore messages that don't match the expected
+                        // response type. Other concurrent requests (e.g.
+                        // a `close` arriving while a `processed` is in
+                        // flight) post their own responses on the same
+                        // worker; rejecting here would cross-poison
+                        // listeners and surface false errors.
+                        break;
                     }
                 }
             };
             const handleError = (error) => {
                 removeListener();
-                reject(error.message);
+                reject(error.error ?? new Error(error.message));
             };
             const removeListener = () => {
                 props.mediaWorker?.removeEventListener('message', handleMessage);
@@ -142,7 +160,9 @@ basePath = '/', { workerScriptUrl = new URL('../../workers/mediaWorker.js', impo
                 },
                 backgroundImage,
             };
-            log?.('Init processor with config', { config: processorSettings });
+            log?.debug({
+                config: processorSettings,
+            }, 'Init processor with config');
             const result = await postMsg('opened', {
                 type: 'open',
                 data: processorSettings,
@@ -152,9 +172,7 @@ basePath = '/', { workerScriptUrl = new URL('../../workers/mediaWorker.js', impo
         }
         catch (error) {
             props.status = PROCESS_STATUS.Error;
-            log?.('Failed to open process', {
-                error: error,
-            });
+            log?.warn({ error: error }, 'Failed to open process');
             return {};
         }
     };
@@ -178,7 +196,7 @@ basePath = '/', { workerScriptUrl = new URL('../../workers/mediaWorker.js', impo
             }
             catch (error) {
                 props.status = PROCESS_STATUS.Error;
-                log?.('Error during the processing, return original track instead.', { error });
+                log?.warn({ error }, 'Error during the processing, return original track instead.');
                 return input;
             }
         }
@@ -196,9 +214,7 @@ basePath = '/', { workerScriptUrl = new URL('../../workers/mediaWorker.js', impo
             }
             catch (error) {
                 props.status = PROCESS_STATUS.Error;
-                log?.('Error during the processing, return original ReadWritableStream instead.', {
-                    error,
-                });
+                log?.warn({ error }, 'Error during the processing, return original ReadWritableStream instead.');
                 return input;
             }
         }
@@ -212,7 +228,8 @@ basePath = '/', { workerScriptUrl = new URL('../../workers/mediaWorker.js', impo
                     const handleMessage = (ev) => {
                         if (ev.data.type === 'processed' ||
                             ev.data.type === 'opened' ||
-                            ev.data.type === 'updated') {
+                            ev.data.type === 'updated' ||
+                            ev.data.type === 'closed') {
                             props.mediaWorker?.removeEventListener('message', handleMessage);
                             resolve(undefined);
                         }
@@ -228,7 +245,7 @@ basePath = '/', { workerScriptUrl = new URL('../../workers/mediaWorker.js', impo
             props.status = PROCESS_STATUS.Updating;
             const backgroundImage = options.backgroundImage &&
                 (await cloneImageRecord(options.backgroundImage));
-            log?.('Update processor config', { config: options });
+            log?.debug({ config: options }, 'Update processor config');
             const transfer = backgroundImage ? [backgroundImage.image] : [];
             const changed = await postMsg('updated', {
                 type: 'update',
@@ -242,24 +259,22 @@ basePath = '/', { workerScriptUrl = new URL('../../workers/mediaWorker.js', impo
         }
         catch (error) {
             props.status = PROCESS_STATUS.Error;
-            log?.('Failed to update process', {
-                error: error,
-            });
+            log?.warn({ error: error }, 'Failed to update process');
             return {};
         }
     };
     const mute = (muted) => {
         postMsg(undefined, { type: 'mute', data: muted });
     };
-    const close = () => {
+    const close = async () => {
         props.status = PROCESS_STATUS.Closing;
-        log?.('Close processor');
-        postMsg(undefined, { type: 'close' });
+        log?.info('Close processor');
+        await postMsg('closed', { type: 'close' });
         props.status = PROCESS_STATUS.Closed;
     };
     const destroy = async () => {
         props.status = PROCESS_STATUS.Destroying;
-        log?.('Destroy processor');
+        log?.info('Destroy processor');
         props.eventHandlers.clear();
         postMsg(undefined, { type: 'destroy' });
         props.mediaWorker?.terminate();

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

@@ -18,7 +18,7 @@ export interface AsyncAssets {
 export interface Process<T> {
     status: ProcessStatus;
     open(): Promise<T>;
-    close(): void;
+    close(): Promise<void>;
     destroy(): Promise<void>;
 }
 export interface BackgroundImage {

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

@@ -21,7 +21,7 @@ export interface VideoProcessor {
     /**
      * Stop the process of video segmentation
      */
-    close(): void;
+    close(): Promise<void>;
     /**
      * Destroy the segmentation wasm instance
      */

package/dist/main/video/video.js

@@ -1,5 +1,4 @@
 import { assert, isEmpty } from '@pexip/utils';
-import { AbortReason } from '../../common/constants';
 import { BACKGROUND_BLUR_AMOUNT, BACKGROUND_THRESHOLD, DOWN_SAMPLE_FACTOR, EDGE_BLUR_AMOUNT, EXCLUDE_BYSTANDERS, FOREGROUND_THRESHOLD, LIGHT_WRAP_BLUR_AMOUNT, LIGHT_WRAP_EDGE_BAND, LIGHT_WRAP_INTENSITY, LIGHT_WRAP_TIGHTNESS, MASK_COMBINE_RATIO, MORPH_DILATE_RADIUS_PX, MORPH_ERODE_RADIUS_PX, MORPH_PASS, PERSON_CENTER, PROCESSING_HEIGHT, PROCESSING_WIDTH, SIGMA_RANGE, SIGMA_SPACE, } from '../../common/constants';
 import { clamping, createObjectUpdater, compareImageRecords, } from '../../common/utils';
 import { assertMediaStreamVideoTrack, isRenderEffects } from './typeGuards';
@@ -278,9 +277,26 @@ export const createVideoProcessor = (segmenter, inputProcessAdaptor) => {
     const update = async (options) => {
         await updateProcessorOptions(options);
     };
-    const process = async (source) => {
+    // Serialization lock: `process()` and `close()` mutate the same worker
+    // pipeline (segmenter + transferred tracks). If they overlap, the worker
+    // can tear down a writable stream while the main thread is still feeding
+    // it, surfacing as `InvalidStateError: Stream closed`. Chain every
+    // public mutation through this promise so they always run end-to-end.
+    let serialized = Promise.resolve();
+    const runSerialized = (fn) => {
+        const next = serialized.then(fn, fn);
+        serialized = next.catch(() => undefined);
+        return next;
+    };
+    const closeImpl = async () => {
+        await segmenter.close();
+        props.outputTrack?.stop();
+        props.outputTrack = undefined;
+        props.processing = false;
+    };
+    const processImpl = async (source) => {
         if (props.processing) {
-            close();
+            await closeImpl();
         }
         assertMediaStreamVideoTrack(source);
         if (segmenter.status === 'new') {
@@ -302,15 +318,10 @@ export const createVideoProcessor = (segmenter, inputProcessAdaptor) => {
         props.processing = true;
         return props.outputTrack;
     };
-    const close = () => {
-        segmenter.close();
-        props.abortController?.abort(AbortReason.Close);
-        props.outputTrack?.stop();
-        props.outputTrack = undefined;
-        props.processing = false;
-    };
+    const process = source => runSerialized(() => processImpl(source));
+    const close = () => runSerialized(closeImpl);
     const destroy = async () => {
-        close();
+        await close();
         processorOptions?.backgroundImage?.image?.close();
         renderOptions = initRenderOptions();
         changedRenderOptions = {};