@pexip/media 20.3.5 → 22.0.0

package/dist/media.js

@@ -7,7 +7,7 @@ import { createGetUserMediaProcess, requestUserMediaWithRetry, } from './userMed
 import { AUDIO_SETTINGS_KEYS, MIXING_SETTINGS_KEYS, PAN_TILT_ZOOM_SETTINGS_KEYS, VIDEO_SETTINGS_KEYS, buildMedia, createMediaProcessor, diffSettings, getDevicesChanges, getSettingsFromKeys, hasPtzFeature, isApplyingRenderEffect, mergeSettings, refineMediaConstraints, } from './utils';
 import { getPermissionStatus, isRequestPermissionNeeded } from './status';
 import { isMedia } from './typeGuard';
-import { updateFeatureProps as getVideoFeatures } from './videoProcessor';
+import { updateFeatureProps as getVideoFeatures, mapFeatureToSettings, mapSettingsToFeatures, } from './videoProcessor';
 import { updateFeatureProps as getAudioFeatures } from './audioProcessor';
 import { updateFeatureProps as getMixingFeatures } from './audioMixingProcessor';
 import { GET_USER_MEDIA_TIMEOUT_MS, DEVICE_CHANGE_DEBOUNCE_TIMEOUT_MS, } from './constants';
@@ -59,7 +59,7 @@ export const createMediaUpdater = ({ getUserMedia, getCurrentDevices, shouldDisc
         const defaultVideoSettings = getSettingsFromKeys(VIDEO_SETTINGS_KEYS, getDefaultConstraints?.().video);
         const videoFeaturesChanged = defaultVideoSettings === false
             ? undefined
-            : diffSettings(VIDEO_SETTINGS_KEYS)(prevVideoSettings ?? defaultVideoSettings, videoFeatures);
+            : diffSettings(VIDEO_SETTINGS_KEYS)(prevVideoSettings ?? defaultVideoSettings, mapFeatureToSettings(videoFeatures));
         const defaultMixingSettings = getSettingsFromKeys(MIXING_SETTINGS_KEYS, getDefaultConstraints?.().audio);
         const mixingFeaturesChanged = defaultMixingSettings === false
             ? undefined
@@ -68,7 +68,7 @@ export const createMediaUpdater = ({ getUserMedia, getCurrentDevices, shouldDisc
         const ptzFeaturesChanges = defaultPTZSettings === false
             ? undefined
             : hasPtzFeature() &&
-                diffSettings(PAN_TILT_ZOOM_SETTINGS_KEYS)(prevVideoSettings ?? defaultPTZSettings, videoFeatures);
+                diffSettings(PAN_TILT_ZOOM_SETTINGS_KEYS)(prevVideoSettings ?? defaultPTZSettings, mapFeatureToSettings(videoFeatures));
         const audioRequest = refineMediaConstraints({
             kind: 'audioinput',
             request: constraints.audio,
@@ -154,8 +154,8 @@ export const createMediaUpdater = ({ getUserMedia, getCurrentDevices, shouldDisc
             : undefined;
         if (audioDiff || videoDiff) {
             await currentMedia?.applyConstraints({
-                audio: audioDiff,
-                video: videoDiff,
+                audio: audioDiff && mapSettingsToFeatures(audioDiff),
+                video: videoDiff && mapSettingsToFeatures(videoDiff),
             });
         }
     };

package/dist/previewController.d.ts

@@ -39,6 +39,7 @@ export interface PreviewStreamParams {
         audio?: InputConstraintSet | false;
         video?: InputConstraintSet | false;
     };
+    stopVideoTrackAsMute?: () => boolean;
 }
 export interface PreviewControllerProps {
     media: Media | undefined;
@@ -51,6 +52,7 @@ export interface PreviewControllerProps {
     discardMedia: boolean;
     initialized: boolean;
     signals: MediaSignals;
+    keepVideoMuted: boolean;
 }
 export interface PreviewStreamController {
     media: Media | undefined;
@@ -83,6 +85,6 @@ export interface PreviewStreamController {
     onVideoMuted(callback: EventCallback<boolean | undefined>): Unsubscribe;
     onVideoSuspended(callback: EventCallback<boolean | undefined>): Unsubscribe;
 }
-export declare const createPreviewStreamController: ({ getCurrentDevices, getCurrentMedia, updateMainStream, onEnded, mainMediaSignal, queueOptions, audioProcessors, videoProcessors, getDefaultConstraints, signals, }: PreviewStreamParams) => PreviewStreamController;
+export declare const createPreviewStreamController: ({ getCurrentDevices, getCurrentMedia, updateMainStream, onEnded, mainMediaSignal, queueOptions, audioProcessors, videoProcessors, getDefaultConstraints, signals, stopVideoTrackAsMute, }: PreviewStreamParams) => PreviewStreamController;
 export type CreatePreviewStreamController = typeof createPreviewStreamController;
 export {};

package/dist/previewController.js

@@ -51,7 +51,7 @@ export const createPreviewStreamController = ({ getCurrentDevices, getCurrentMed
     throttleInMS: DEFAULT_QUEUE_THROTTLE_MS,
     delayInMS: DEFAULT_QUEUE_DELAY_MS,
     dropLast: DEFAULT_QUEUE_DROP_LAST,
-}, audioProcessors, videoProcessors, getDefaultConstraints = () => ({}), signals, }) => {
+}, audioProcessors, videoProcessors, getDefaultConstraints = () => ({}), signals, stopVideoTrackAsMute = () => false, }) => {
     const queue = createAsyncQueue(queueOptions);
     const eventHandlers = {};
     const internalProps = {
@@ -62,6 +62,7 @@ export const createPreviewStreamController = ({ getCurrentDevices, getCurrentMed
         discardMedia: false,
         initialized: false,
         signals,
+        keepVideoMuted: false,
     };
     const logger = createModuleLogger({
         module: 'PreviewStreamController',
@@ -125,7 +126,7 @@ export const createPreviewStreamController = ({ getCurrentDevices, getCurrentMed
                 eventHandlers.audioMuted?.(track.muted);
             }
             else {
-                eventHandlers.videoMuted?.(track.muted);
+                eventHandlers.videoMuted?.(props.keepVideoMuted || track.muted);
             }
         }),
         props.signals.onMediaTrackSuspended?.add(track => {
@@ -151,7 +152,9 @@ export const createPreviewStreamController = ({ getCurrentDevices, getCurrentMed
                     break;
                 }
                 case 'video': {
-                    eventHandlers.videoMuted?.(isTrackMuted(track) || isTrackEnded(track));
+                    eventHandlers.videoMuted?.(props.keepVideoMuted ||
+                        isTrackMuted(track) ||
+                        isTrackEnded(track));
                     break;
                 }
             }
@@ -163,7 +166,9 @@ export const createPreviewStreamController = ({ getCurrentDevices, getCurrentMed
                     break;
                 }
                 case 'video': {
-                    eventHandlers.videoMuted?.(isTrackMuted(track) || isTrackEnded(track));
+                    eventHandlers.videoMuted?.(props.keepVideoMuted ||
+                        isTrackMuted(track) ||
+                        isTrackEnded(track));
                     break;
                 }
             }
@@ -173,7 +178,7 @@ export const createPreviewStreamController = ({ getCurrentDevices, getCurrentMed
         getUserMedia: requestUserMediaWithRetry(() => Promise.resolve(getCurrentDevices())),
         signals: props.signals,
         getCurrentDevices: () => Promise.resolve(getCurrentDevices()),
-        stopVideoTrackAsMute: () => false,
+        stopVideoTrackAsMute,
         updateMedia: constraints => updateMedia(constraints),
     });
     const mergeMediaConstraints = (constraints) => {
@@ -223,6 +228,14 @@ export const createPreviewStreamController = ({ getCurrentDevices, getCurrentMed
         getCurrentDevices: () => Promise.resolve(getCurrentDevices()),
         shouldDiscardMedia: () => props.discardMedia,
         onMediaTracksChanged: (media, tracks) => {
+            if (props.keepVideoMuted) {
+                for (const track of tracks) {
+                    if (track.kind === 'videoinput') {
+                        track.mute(true);
+                    }
+                }
+                props.keepVideoMuted = false;
+            }
             props.media = media;
             queue.enqueue(async () => {
                 await processAndUpdateMedia(media, tracks, false);
@@ -328,14 +341,16 @@ export const createPreviewStreamController = ({ getCurrentDevices, getCurrentMed
             props.updatingPreviewAudio = false;
         }
     };
-    const updateVideoInput = async (input) => {
+    const updateVideoInput = async (input, syncMuteState = true) => {
         try {
             props.videoInput = input;
             props.updatingPreviewVideo = true;
             if (input === undefined) {
                 return await releaseVideo();
             }
-            return await updatePreviewMedia({ video: { device: { exact: input } } });
+            props.keepVideoMuted = syncMuteState && !!props.media?.videoMuted;
+            await updatePreviewMedia({ video: { device: { exact: input } } });
+            return;
         }
         catch (error) {
             if (error instanceof Error) {
@@ -373,7 +388,7 @@ export const createPreviewStreamController = ({ getCurrentDevices, getCurrentMed
             const audioSettings = extractFeaturesToConstraints(AUDIO_SETTINGS_KEYS, previewAudio);
             // Omit the width & height settings from the preview so that the one
             // from the main can be applied
-            const { width: _width, height: _height, ...videoSettings } = extractFeaturesToConstraints(VIDEO_SETTINGS_KEYS, previewVideo);
+            const { width: _width, height: _height, edgeBlurAmount: _edgeBlurAmount, lightWrapBlurAmount: _lightWrapBlurAmount, backgroundBlurAmount: _backgroundBlurAmount, ...videoSettings } = extractFeaturesToConstraints(VIDEO_SETTINGS_KEYS, previewVideo);
             logger.info({ audioInput, videoInput, audioSettings, videoSettings }, 'Apply changes to main');
             try {
                 await replaceMainStream({
@@ -475,7 +490,7 @@ export const createPreviewStreamController = ({ getCurrentDevices, getCurrentMed
                     return updateAudioInput(input);
                 }
                 case 'videoinput': {
-                    return updateVideoInput(input);
+                    return updateVideoInput(input, false);
                 }
             }
         },

package/dist/typeGuard.d.ts

@@ -1,5 +1,5 @@
 import type { AnalyzerNodeInit } from '@pexip/media-processor';
-import type { AudioContentHint, Media, VideoContentHint, VideoStreamTrackProcessorAPIs } from './types';
+import type { AudioContentHint, Media, VideoContentHint } from './types';
 import { UserMediaStatus } from './types';
 export declare const isNonNullObject: (value: unknown) => value is Record<string, unknown>;
 export declare const isUserMediaStatus: (value: unknown) => value is UserMediaStatus;
@@ -7,4 +7,3 @@ export declare const isMedia: (value: unknown) => value is Media;
 export declare const isAnalyzerNodeInitProp: (value: unknown) => value is AnalyzerNodeInit | undefined;
 export declare const isAudioContentHint: (value: unknown) => value is AudioContentHint;
 export declare const isVideoContentHint: (value: unknown) => value is VideoContentHint;
-export declare const isVideoStreamTrackProcessorAPIs: (value: unknown) => value is VideoStreamTrackProcessorAPIs;

package/dist/typeGuard.js

@@ -38,6 +38,3 @@ export const isVideoContentHint = (value) => {
     }
     return false;
 };
-export const isVideoStreamTrackProcessorAPIs = (value) => {
-    return (typeof value === 'string' && (value === 'stream' || value === 'canvas'));
-};

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import type { IndexedDevices, InputConstraintSet, InputDeviceConstraint, MediaDeviceInfoLike, MediaDeviceRequest } from '@pexip/media-control';
-import type { RendererOptions, RenderEffects, Segmenter, SegmentationModel } from '@pexip/media-processor';
+import type { RendererOptions, RenderEffects } from '@pexip/media-processor';
 import type { Signal } from '@pexip/signal';
 export type Unsubscribe = () => void;
 export interface ExtendedMediaTrackSettings extends MediaTrackSettings {
@@ -14,10 +14,12 @@ export interface ExtendedMediaTrackSettings extends MediaTrackSettings {
     maskCombineRatio?: number;
     foregroundThreshold?: number;
     videoSegmentation?: RenderEffects;
-    videoSegmentationModel?: SegmentationModel;
-    pan?: boolean;
-    tilt?: boolean;
-    zoom?: boolean;
+    panEnabled?: boolean;
+    tiltEnabled?: boolean;
+    zoomEnabled?: boolean;
+    pan?: number;
+    tilt?: number;
+    zoom?: number;
     contentHint?: AudioContentHint | VideoContentHint;
 }
 export type ExtendedMediaTrackSettingsKey = keyof ExtendedMediaTrackSettings;
@@ -230,12 +232,6 @@ export type GetUserMediaProcess = (request: {
     };
     currentMedia: Media | undefined;
 }) => Promise<Media>;
-/**
- * Use which processor API to process the stream track
- * `stream` - Use `MediaStreamTrackProcessor`, when available
- * `canvas` - Use Canvas
- */
-export type VideoStreamTrackProcessorAPIs = 'stream' | 'canvas';
 export declare enum UserMediaStatus {
     /**
      * The initial status
@@ -531,7 +527,7 @@ export interface MediaController {
      */
     tryAndGetUserMedia: (constraints: MediaDeviceRequest) => void;
 }
-export type VideoRenderParams = Omit<RendererOptions, 'effects'> & {
+export type VideoRenderParams = Omit<RendererOptions, 'effects' | 'personCenter'> & {
     /**
      * Target frame rate for the video segmentation
      */
@@ -545,6 +541,8 @@ export type VideoRenderParams = Omit<RendererOptions, 'effects'> & {
     pan?: boolean;
     tilt?: boolean;
     zoom?: boolean;
+    personCenterX?: number;
+    personCenterY?: number;
 };
 export interface MediaChangesSignals {
     onAddTrack: Signal<MediaStreamTrack>;
@@ -571,9 +569,6 @@ export declare enum DeniedDevices {
     Camera = "camera",
     Both = "microphone-and-camera"
 }
-export type Segmenters = {
-    [Property in SegmentationModel]: Segmenter;
-};
 /**
  * Audio content hints are only applicable when the MediaStreamTrack contains an
  * audio track

package/dist/userMedia.d.ts

@@ -11,7 +11,10 @@ export declare const toSameDeviceStatus: ({ audio, video, }: {
     audio: boolean;
     video: boolean;
 }) => UserMediaStatus.PermissionsGranted | UserMediaStatus.PermissionsGrantedFallback | UserMediaStatus.PermissionsGrantedFallbackAudioinput | UserMediaStatus.PermissionsGrantedFallbackVideoinput;
-export declare const toOnlyDeviceStatus: (kind: "audioinput" | "videoinput", matched: boolean, devices: IndexedDevices) => UserMediaStatus.PermissionsRejectedAudioInput | UserMediaStatus.PermissionsRejectedVideoInput | UserMediaStatus.PermissionsOnlyAudioinput | UserMediaStatus.PermissionsOnlyAudioinputNoVideoDevices | UserMediaStatus.PermissionsOnlyAudioinputFallback | UserMediaStatus.PermissionsOnlyAudioinputFallbackNoVideoDevices | UserMediaStatus.PermissionsOnlyVideoinput | UserMediaStatus.PermissionsOnlyVideoinputNoAudioDevices | UserMediaStatus.PermissionsOnlyVideoinputFallback | UserMediaStatus.PermissionsOnlyVideoinputFallbackNoAudioDevices;
+export declare const toOnlyDeviceStatus: (kind: "audioinput" | "videoinput", streamedRequestedDevices: {
+    audio: boolean;
+    video: boolean;
+}, devices: IndexedDevices) => UserMediaStatus.PermissionsRejectedAudioInput | UserMediaStatus.PermissionsRejectedVideoInput | UserMediaStatus.PermissionsOnlyAudioinput | UserMediaStatus.PermissionsOnlyAudioinputNoVideoDevices | UserMediaStatus.PermissionsOnlyAudioinputFallback | UserMediaStatus.PermissionsOnlyAudioinputFallbackNoVideoDevices | UserMediaStatus.PermissionsOnlyVideoinput | UserMediaStatus.PermissionsOnlyVideoinputNoAudioDevices | UserMediaStatus.PermissionsOnlyVideoinputFallback | UserMediaStatus.PermissionsOnlyVideoinputFallbackNoAudioDevices;
 /**
  * Check if there is any track match with the `kind`
  */

package/dist/userMedia.js

@@ -71,12 +71,16 @@ export const toSameDeviceStatus = ({ audio, video, }) => {
     }
     return UserMediaStatus.PermissionsGrantedFallback;
 };
-export const toOnlyDeviceStatus = (kind, matched, devices) => {
-    const hasAnotherTypeOfAuthorizedDevice = devices.anyAuthorizedDevice(kind === 'audioinput' ? 'videoinput' : 'audioinput');
-    const hasAnotherTypeOfDevice = devices.size(kind === 'audioinput' ? 'videoinput' : 'audioinput') > 0;
+export const toOnlyDeviceStatus = (kind, streamedRequestedDevices, devices) => {
+    const [self, other] = kind === 'audioinput' ? ['audio', 'video'] : ['video', 'audio'];
+    const otherKind = kind === 'audioinput' ? 'videoinput' : 'audioinput';
+    const matched = streamedRequestedDevices[self];
+    const anotherDeviceRequested = streamedRequestedDevices[other];
+    const hasAnotherTypeOfAuthorizedDevice = devices.anyAuthorizedDevice(otherKind);
+    const hasAnotherTypeOfDevice = devices.size(otherKind) > 0;
     if (matched) {
         if (hasAnotherTypeOfDevice) {
-            if (hasAnotherTypeOfAuthorizedDevice) {
+            if (hasAnotherTypeOfAuthorizedDevice || !anotherDeviceRequested) {
                 return kind === 'audioinput'
                     ? UserMediaStatus.PermissionsOnlyAudioinput
                     : UserMediaStatus.PermissionsOnlyVideoinput;
@@ -90,7 +94,7 @@ export const toOnlyDeviceStatus = (kind, matched, devices) => {
             : UserMediaStatus.PermissionsOnlyVideoinputNoAudioDevices;
     }
     if (hasAnotherTypeOfDevice) {
-        if (hasAnotherTypeOfAuthorizedDevice) {
+        if (hasAnotherTypeOfAuthorizedDevice || !anotherDeviceRequested) {
             return kind === 'audioinput'
                 ? UserMediaStatus.PermissionsOnlyAudioinputFallback
                 : UserMediaStatus.PermissionsOnlyVideoinputFallback;
@@ -421,10 +425,10 @@ export const requestUserMedia = (getCurrentDevices, getMedia = getUserMedia) =>
                 ? constraints.video
                 : false,
         });
-        const { audio, video } = isStreamingRequestedDevices(constraints, stream, devices);
-        const onlyAudioStatus = toOnlyDeviceStatus('audioinput', audio, devices);
-        const onlyVideoStatus = toOnlyDeviceStatus('videoinput', video, devices);
-        const status = deriveDeviceStatus(onlyAudioStatus, onlyVideoStatus, toSameDeviceStatus({ audio, video }));
+        const streamedRequestedDevices = isStreamingRequestedDevices(constraints, stream, devices);
+        const onlyAudioStatus = toOnlyDeviceStatus('audioinput', streamedRequestedDevices, devices);
+        const onlyVideoStatus = toOnlyDeviceStatus('videoinput', streamedRequestedDevices, devices);
+        const status = deriveDeviceStatus(onlyAudioStatus, onlyVideoStatus, toSameDeviceStatus(streamedRequestedDevices));
         return [stream, status];
     }
     catch (error) {
@@ -521,10 +525,10 @@ export const createGetUserMediaProcess = ({ getCurrentDevices, getUserMedia, sco
                 }));
         }
         const relaxedConstraints = {};
-        if (constraints.audio) {
+        if (constraints.audio !== undefined) {
             relaxedConstraints.audio = relaxInputConstraint('audioinput', constraints.audio, currentDevices);
         }
-        if (constraints.video) {
+        if (constraints.video !== undefined) {
             relaxedConstraints.video = relaxInputConstraint('videoinput', constraints.video, currentDevices);
         }
         const [stream, status] = await getUserMedia(relaxedConstraints);

package/dist/utils.d.ts

@@ -54,17 +54,28 @@ export declare const getSettingsFromKeys: (keys: ExtendedMediaTrackSettingsKey[]
 export declare const diffSettings: (keysToLookFor: ExtendedMediaTrackSettingsKey[]) => (settingsA: ExtendedMediaTrackSettings | undefined, settingsB: ExtendedMediaTrackSettings | undefined) => ExtendedMediaTrackSettings | undefined;
 export declare const mergeSettings: (settingsA: ExtendedMediaTrackSettings | undefined, settingsB: ExtendedMediaTrackSettings | undefined) => ExtendedMediaTrackSettings | undefined;
 /**
- * A function to get the blur kernel size of image height
+ * A function to get the blur kernel size of image height based on
+ * Kawase blur algorithm
  *
- * @param percentage - The percentage of image height to calculate the blur
- * kernel size
- * @param height - The image height
- * @param lowestProcessingHeight - The lowest image height that is processed by the consumer, used to adjust the blur kernel size across different resolutions
+ * @param norm - [0-100] The normalized blur amount
+ * @param heightRef - The reference image height
+ * @param height - The current image height
  * @param max - The upper bound
  *
  * @returns blur kernel size
  */
-export declare const getBlurKernelSize: (percentage: number, height: number, lowestProcessingHeight?: number, max?: number) => number;
+export declare const getBlurKernelSize: (norm: number, heightRef: number, height: number, max?: number) => number;
+/**
+ * A function to get the Tent blur size of image height
+ *
+ * @param norm - [0-100] The normalized blur amount
+ * @param heightRef - The reference image height
+ * @param height - The current image height
+ * @param max - The upper bound
+ *
+ * @returns tent blur size
+ */
+export declare const getTentBlurSize: (norm: number, heightRef: number, height: number, max?: number) => number;
 /**
  * Apply the content hint to the track
  *

package/dist/utils.js

@@ -1,7 +1,9 @@
 import { createStreamTrackEventSubscriptions, createTrackDevicesChanges, extractConstraintsWithKeys, findDeviceFromConstraints, relaxInputConstraint, resolveMediaDeviceConstraints, shouldRequestDevice, toMediaDeviceInputKind, } from '@pexip/media-control';
-import { calculateMaxBlurPass } from '@pexip/media-processor';
+import { calculateMaxBlurPass, clamping, } from '@pexip/media-processor';
 import { hasOwn, assert, isEmpty } from '@pexip/utils';
 import { internalSignals } from './signals';
+import { MAX_TENT_BLUR_SIZE } from './constants';
+import { mapFeatureToSettings } from './videoProcessor';
 export const makeDeriveDeviceStatus = (constraints) => (audio, video, both) => {
     if (constraints.audio) {
         if (constraints.video) {
@@ -570,7 +572,6 @@ export const AUDIO_SETTINGS_KEYS = [
 export const VIDEO_SETTINGS_KEYS = [
     'frameRate',
     'videoSegmentation',
-    'videoSegmentationModel',
     'foregroundThreshold',
     'backgroundBlurAmount',
     'edgeBlurAmount',
@@ -628,10 +629,11 @@ export const getSettingsFromKeys = (keys, settings) => {
         return settings;
     }
     const result = {};
+    const mapped = mapFeatureToSettings(settings);
     for (const key of keys) {
-        if (settings[key] !== undefined) {
+        if (mapped[key] !== undefined) {
             // @ts-expect-error --- Type issue and need to be fixed when we have time
-            result[key] = settings[key];
+            result[key] = mapped[key];
         }
     }
     return result;
@@ -684,26 +686,39 @@ export const mergeSettings = (settingsA, settingsB) => {
     }
     return { ...settingsA, ...settingsB };
 };
+const clampNorm = clamping(0, 100);
 /**
- * A function to get the blur kernel size of image height
+ * A function to get the blur kernel size of image height based on
+ * Kawase blur algorithm
  *
- * @param percentage - The percentage of image height to calculate the blur
- * kernel size
- * @param height - The image height
- * @param lowestProcessingHeight - The lowest image height that is processed by the consumer, used to adjust the blur kernel size across different resolutions
+ * @param norm - [0-100] The normalized blur amount
+ * @param heightRef - The reference image height
+ * @param height - The current image height
  * @param max - The upper bound
  *
  * @returns blur kernel size
  */
-export const getBlurKernelSize = (percentage, height, lowestProcessingHeight, max = calculateMaxBlurPass(height)) => {
-    if (height <= 0 || percentage <= 0 || max <= 0) {
+export const getBlurKernelSize = (norm, heightRef, height, max = calculateMaxBlurPass(height)) => {
+    if (height <= 0 || norm <= 0 || max <= 0 || heightRef <= 0) {
         return 0;
     }
-    const minHeightMaxBlurPass = lowestProcessingHeight
-        ? calculateMaxBlurPass(lowestProcessingHeight)
-        : max;
-    return Math.min(Math.ceil(percentage * 0.01 * max) +
-        Math.max(0, max - minHeightMaxBlurPass), max);
+    return clamping(0, max)(Math.round(clampNorm(norm) * 0.01 * max - Math.log2(heightRef / height)));
+};
+/**
+ * A function to get the Tent blur size of image height
+ *
+ * @param norm - [0-100] The normalized blur amount
+ * @param heightRef - The reference image height
+ * @param height - The current image height
+ * @param max - The upper bound
+ *
+ * @returns tent blur size
+ */
+export const getTentBlurSize = (norm, heightRef, height, max = MAX_TENT_BLUR_SIZE) => {
+    if (height <= 0 || norm <= 0 || heightRef <= 0 || max <= 0) {
+        return 0;
+    }
+    return clamping(0, max)(Math.round((norm * 0.01 * max * height) / heightRef));
 };
 /**
  * Apply the content hint to the track

package/dist/videoProcessor.d.ts

@@ -1,27 +1,15 @@
-import type { RenderBackend, SegmentationModel, SegmentationTransform, VideoProcessor } from '@pexip/media-processor';
-import type { MediaDeviceRequest } from '@pexip/media-control';
-import type { MediaSignals, Segmenters, TrackProcessor, VideoContentHint, VideoRenderParams, VideoStreamTrackProcessorAPIs } from './types';
-interface ProcessorDeps {
-    segmenters: Partial<Segmenters>;
-    transformer?: SegmentationTransform;
-    videoProcessor?: () => VideoProcessor;
-    videoSegmentationModel?: SegmentationModel;
-}
-interface VideoStreamProcessOptions extends Partial<VideoRenderParams>, Omit<ProcessorDeps, 'videoProcessor'> {
-    /**
-     * What API to use for processing the MediaStreamTrack
-     * `stream` - Use MediaStreamTrackProcessor, when available
-     * `canvas` - Use Canvas
-     */
-    trackProcessorAPI?: () => VideoStreamTrackProcessorAPIs;
+import type { RenderBackend, VideoProcessor } from '@pexip/media-processor';
+import type { InputConstraintSet, MediaDeviceRequest } from '@pexip/media-control';
+import type { ExtendedMediaTrackSettings, MediaSignals, TrackProcessor, VideoContentHint, VideoRenderParams } from './types';
+interface VideoStreamProcessOptions extends Partial<VideoRenderParams> {
     /**
      * Whether or to enable this processor
      */
     shouldEnable: () => boolean;
-    lowestProcessingHeight?: number;
+    getVideoProcessor: () => VideoProcessor;
+    referenceProcessingHeight?: number;
     processingWidth: number;
     processingHeight: number;
-    hasInitializedDeps?: boolean;
     width?: number;
     height?: number;
     label?: string;
@@ -30,13 +18,43 @@ interface VideoStreamProcessOptions extends Partial<VideoRenderParams>, Omit<Pro
     gpuAPI?: () => RenderBackend;
     signals?: MediaSignals;
 }
-interface VideoStreamProcessProps extends Partial<VideoRenderParams>, Required<ProcessorDeps> {
-    hasInitialized: boolean;
+interface VideoStreamProcessProps extends Partial<VideoRenderParams> {
     contentHint?: VideoContentHint;
 }
-declare const FEATURE_KEYS: readonly ["backgroundBlurAmount", "backgroundImageUrl", "maskCombineRatio", "edgeBlurAmount", "foregroundThreshold", "frameRate", "videoSegmentation", "videoSegmentationModel", "width", "height", "pan", "tilt", "zoom", "contentHint"];
-type FeaturePropKeys = (typeof FEATURE_KEYS)[number];
+declare const FEATURE_KEYS: {
+    readonly backgroundBlurAmount: "number";
+    readonly backgroundImageUrl: "string";
+    readonly backgroundThreshold: "number";
+    readonly maskCombineRatio: "number";
+    readonly edgeBlurAmount: "number";
+    readonly foregroundThreshold: "number";
+    readonly frameRate: "number";
+    readonly videoSegmentation: "string";
+    readonly width: "number";
+    readonly height: "number";
+    readonly pan: "boolean";
+    readonly tilt: "boolean";
+    readonly zoom: "boolean";
+    readonly contentHint: "string";
+    readonly sigmaSpace: "number";
+    readonly sigmaRangeLo: "number";
+    readonly sigmaRangeHi: "number";
+    readonly excludeBystanders: "boolean";
+    readonly personCenterX: "number";
+    readonly personCenterY: "number";
+    readonly morphErodeRadiusPx: "number";
+    readonly morphPass: "number";
+    readonly morphDilateRadiusPx: "number";
+    readonly lightWrapIntensity: "number";
+    readonly lightWrapTightness: "number";
+    readonly lightWrapEdgeBand: "number";
+    readonly lightWrapBlurAmount: "number";
+    readonly downSampleFactor: "number";
+};
+type FeaturePropKeys = keyof typeof FEATURE_KEYS;
 type FeatureProps = Pick<Partial<VideoStreamProcessProps>, FeaturePropKeys>;
 export declare const updateFeatureProps: (constraints: MediaDeviceRequest["video"], props: FeatureProps) => FeatureProps;
-export declare const createVideoStreamProcess: ({ backgroundImageUrl, dynamicProcessingDimensions, edgeBlurAmount, foregroundThreshold, frameRate, gpuAPI, label, lowestProcessingHeight, maskCombineRatio, processingHeight, processingWidth, shouldEnable, stopAsMute, trackProcessorAPI, videoSegmentation, signals, ...options }: VideoStreamProcessOptions) => TrackProcessor;
+export declare const mapFeatureToSettings: (props: InputConstraintSet) => ExtendedMediaTrackSettings;
+export declare const mapSettingsToFeatures: (settings: ExtendedMediaTrackSettings) => InputConstraintSet;
+export declare const createVideoStreamProcess: ({ backgroundImageUrl, dynamicProcessingDimensions, backgroundThreshold, downSampleFactor, foregroundThreshold, lightWrapEdgeBand, lightWrapIntensity, lightWrapTightness, morphDilateRadiusPx, morphErodeRadiusPx, morphPass, personCenterX, personCenterY, sigmaSpace, sigmaRangeHi, sigmaRangeLo, frameRate, gpuAPI, label, referenceProcessingHeight, maskCombineRatio, processingHeight, processingWidth, shouldEnable, stopAsMute, videoSegmentation, signals, getVideoProcessor, ...options }: VideoStreamProcessOptions) => TrackProcessor;
 export {};