@pexip/media 18.5.0 → 19.1.0

package/dist/utils.js

@@ -1,41 +1,165 @@
-import { applyConstraints, createTrackDevicesChanges, extractConstraintsWithKeys, findDeviceFromConstraints, muteStreamTrack, relaxInputConstraint, stopMediaStream, isAudioInput, isVideoInput, } from '@pexip/media-control';
+import { createStreamTrackEventSubscriptions, createTrackDevicesChanges, extractConstraintsWithKeys, findDeviceFromConstraints, relaxInputConstraint, resolveMediaDeviceConstraints, shouldRequestDevice, toMediaDeviceInputKind, } from '@pexip/media-control';
 import { calculateMaxBlurPass } from '@pexip/media-processor';
-import { hasOwn } from '@pexip/utils';
-import { UserMediaStatus } from './types';
-import { isOverConstrained } from './status';
-import { isMedia } from './typeGuard';
+import { hasOwn, assert, isEmpty } from '@pexip/utils';
+import { internalSignals } from './signals';
 export const makeDeriveDeviceStatus = (constraints) => (audio, video, both) => {
-    if (!constraints.audio && constraints.video) {
-        return video;
-    }
-    if (!constraints.video && constraints.audio) {
+    if (constraints.audio === undefined || constraints.audio) {
+        if (constraints.video === undefined || constraints.video) {
+            return both;
+        }
         return audio;
     }
+    if (constraints.video === undefined || constraints.video) {
+        return video;
+    }
     return both;
 };
-export const createMediaProcess = (process) => async (mediaP) => {
-    const media = await mediaP;
-    return process(media) ?? media;
-};
-export const createMediaPipeline = (init) => {
-    const getPipeline = () => (typeof init === 'function' ? init() : init);
-    return {
-        pipe: (process) => {
-            getPipeline().push(process);
-        },
-        execute: async (m) => {
-            const [first, ...processes] = getPipeline();
-            if (first) {
-                const piped = processes.reduce((prev, next) => next(prev), first(m));
-                return piped;
+export const createMediaTrack = (trackInit) => {
+    assert(trackInit.track === undefined ||
+        (trackInit.kind === trackInit.input?.kind &&
+            trackInit.kind === toMediaDeviceInputKind(trackInit.track),
+            'Inconsistent track kind'));
+    const currentConstraints = typeof trackInit.constraints === 'boolean' ? {} : trackInit.constraints;
+    // Find the original source track through the linked list
+    let sourceMediaTrack = trackInit.previousMediaTrack;
+    while (sourceMediaTrack?.previousMediaTrack) {
+        sourceMediaTrack = sourceMediaTrack.previousMediaTrack;
+    }
+    const getConstraints = () => {
+        if (trackInit.constraints === false) {
+            return false;
+        }
+        return {
+            ...currentConstraints,
+            ...trackInit.track?.getConstraints(),
+        };
+    };
+    const getSettings = () => {
+        return {
+            ...trackInit.previousMediaTrack?.getSettings(),
+            ...trackInit.track?.getSettings(),
+            ...(trackInit.getSettings?.() ?? {}),
+        };
+    };
+    const mediaTrack = {
+        get kind() {
+            return trackInit.kind;
+        },
+        get id() {
+            return trackInit.id ?? trackInit.track?.id ?? trackInit.kind;
+        },
+        get track() {
+            return trackInit.track;
+        },
+        get input() {
+            return trackInit.input;
+        },
+        get expectedInput() {
+            return trackInit.expectedInput;
+        },
+        get label() {
+            return trackInit.label;
+        },
+        get previousMediaTrack() {
+            return trackInit.previousMediaTrack;
+        },
+        get muted() {
+            if (trackInit.overrideMute) {
+                return trackInit.muted;
+            }
+            return (
+            // If the source track muted, the following processed track will
+            // be muted as well since there is no data to process
+            !!isTrackMuted(this.source.track) ||
+                isTrackMuted(trackInit.track));
+        },
+        get source() {
+            return sourceMediaTrack ?? mediaTrack;
+        },
+        mute(toMute) {
+            if (trackInit.overrideMute) {
+                return trackInit.mute?.(toMute);
             }
-            const media = m instanceof Promise ? (await m) : m;
-            if (isMedia(media)) {
-                return Promise.resolve(media);
+            trackInit.previousMediaTrack?.mute(toMute);
+            if (trackInit.track) {
+                trackInit.track.enabled = !toMute;
             }
-            throw new Error('Expect a media input or a processor');
+        },
+        getSettings,
+        getConstraints() {
+            return getConstraints();
+        },
+        clone() {
+            return createMediaTrack({
+                ...trackInit,
+                constraints: getConstraints(),
+                track: trackInit.track?.clone(),
+            });
+        },
+        async applyConstraints(constraints) {
+            const resolvedConstraints = resolveMediaDeviceConstraints(constraints);
+            if (typeof resolvedConstraints === 'boolean' ||
+                resolvedConstraints === undefined) {
+                return Promise.resolve();
+            }
+            await trackInit.previousMediaTrack?.applyConstraints(resolvedConstraints);
+            await trackInit.applyConstraints?.(constraints);
+            if (trackInit.track) {
+                if ('contentHint' in resolvedConstraints &&
+                    typeof resolvedConstraints.contentHint === 'string' &&
+                    trackInit.track.contentHint !==
+                        resolvedConstraints.contentHint) {
+                    trackInit.track.contentHint =
+                        resolvedConstraints.contentHint;
+                }
+                const settings = trackInit.track.getSettings();
+                const reducedConstraints = Object.keys(resolvedConstraints).reduce((accm, key) => {
+                    const constraintKey = key;
+                    if (constraintKey in settings) {
+                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment --- Type issue and need to be fixed when we have time
+                        // @ts-expect-error
+                        accm[constraintKey] =
+                            resolvedConstraints[constraintKey];
+                    }
+                    return accm;
+                }, {});
+                // Firefox will throw an error if passing an empty constraint object
+                if (!isEmpty(reducedConstraints)) {
+                    await trackInit.track.applyConstraints(reducedConstraints);
+                }
+            }
+            // Update the current constraints
+            Object.assign(currentConstraints, resolvedConstraints);
+        },
+        async release() {
+            trackInit.track?.stop();
+            if (trackInit.track) {
+                trackInit.signals?.onTrackReleased?.emit(trackInit.track);
+                trackInit.signals?.[trackInit.track.kind === 'audio'
+                    ? 'onAudioMuteStateChanged'
+                    : 'onVideoMuteStateChanged']?.emit(undefined);
+            }
+            await trackInit.previousMediaTrack?.release();
+            await trackInit.release?.();
+        },
+        toJSON() {
+            return {
+                label: trackInit.label,
+                track: trackInit.track,
+                previousMediaTrack: trackInit.previousMediaTrack,
+                constraints: getConstraints(),
+                settings: getSettings(),
+            };
         },
     };
+    return mediaTrack;
+};
+export const createTrackProcessingPipeline = (processors) => async (track) => {
+    let lastTrack = track;
+    for (const process of processors) {
+        lastTrack = await process(lastTrack);
+    }
+    return lastTrack;
 };
 /**
  * Interpret provided input to resolve to a MediaDeviceInfoLike when possible
@@ -50,30 +174,15 @@ export const interpretInput = (input, getCurrentInput) => {
     }
     return input;
 };
-/**
- * Memorized Expected Input
- */
-export const createMemorizedGetExpectedInput = () => {
-    const props = {
-        cachedExpectedInputs: new Map(),
-    };
-    return (constraints, getInfo) => {
-        if (props.cachedExpectedInputs.has(constraints)) {
-            return props.cachedExpectedInputs.get(constraints);
-        }
-        const { devices, input } = getInfo();
-        // Update cache
-        const relaxedConstraints = relaxInputConstraint(constraints, devices);
-        const { device: [[device] = []], } = extractConstraintsWithKeys(['device'])(relaxedConstraints);
-        // The result from `findDeviceFromConstraints` has more restrictive
-        // result since it also consider if the device can be found from the
-        // device list
-        const found = device ?? findDeviceFromConstraints(constraints, devices);
-        const expectedInput = interpretInput(found, () => input);
-        props.cachedExpectedInputs.clear();
-        props.cachedExpectedInputs.set(constraints, expectedInput);
-        return expectedInput;
-    };
+export const findExpectedInput = (devices, constraints, input, kind) => {
+    const relaxedConstraints = relaxInputConstraint(kind, constraints, devices);
+    const { device: [[device] = []], } = extractConstraintsWithKeys(['device'])(relaxedConstraints);
+    // The result from `findDeviceFromConstraints` has more restrictive
+    // result since it also consider if the device can be found from the
+    // device list
+    const found = device ?? findDeviceFromConstraints(constraints, devices);
+    const expectedInput = interpretInput(found, () => input);
+    return expectedInput;
 };
 /**
  * A utility function to check if the provided track is muted. There are
@@ -86,150 +195,294 @@ export const createMemorizedGetExpectedInput = () => {
  * |     false       | false | true  |
  * ```
  *
- * @param tracks - The tracks can be got from `MediaStream['getAudioStats']` or
+ * @param track - The tracks can be got from `MediaStream['getAudioStats']` or
  * `MediaStream['getVideoTracks']`
  *
  * @returns `true` means muted, `false` means not muted and `undefined` means
  * there is no track to check
  */
-export const isMuted = (tracks) => {
-    if (!tracks?.length) {
+export const isTrackMuted = (track) => {
+    if (!track || track.readyState === 'ended') {
         return undefined;
     }
-    return !tracks.some(track => !track.muted && track.enabled);
+    return track.muted || !track.enabled;
 };
-export const buildMedia = (getMedia, onSetStatus) => {
+export const buildMedia = (mediaInit, onDevicesChanged = internalSignals.onDevicesChanged) => {
     const props = {
-        status: getMedia().status ?? UserMediaStatus.Initial,
-        devices: getMedia().devices ?? [],
-        constraints: getMedia().constraints,
+        originalConstraints: mediaInit.originalConstraints ?? mediaInit.constraints,
+        status: mediaInit.status,
+        devices: mediaInit.devices,
+        stream: mediaInit.stream ?? new MediaStream(),
+        audioTrack: mediaInit.tracks
+            .flatMap(track => {
+            return track.kind === 'audioinput' ? [track] : [];
+        })
+            .at(0),
+        videoTrack: mediaInit.tracks
+            .flatMap(track => (track.kind === 'videoinput' ? [track] : []))
+            .at(0),
+    };
+    const subscribeTrackEvents = (track) => createStreamTrackEventSubscriptions(track, {
+        ended: track => {
+            mediaInit.signals?.[track.kind === 'audio'
+                ? 'onAudioMuteStateChanged'
+                : 'onVideoMuteStateChanged']?.emit(undefined);
+            mediaInit.signals?.onStreamTrackEndedFinal?.emit(track);
+        },
+        mute: track => {
+            mediaInit.signals?.[track.kind === 'audio'
+                ? 'onAudioMuteStateChanged'
+                : 'onVideoMuteStateChanged']?.emit(true);
+            mediaInit.signals?.onStreamTrackMuted?.emit(track);
+        },
+        unmute: track => {
+            mediaInit.signals?.[track.kind === 'audio'
+                ? 'onAudioMuteStateChanged'
+                : 'onVideoMuteStateChanged']?.emit(!track.enabled);
+            mediaInit.signals?.onStreamTrackUnmuted?.emit(track);
+        },
+    });
+    const subscribeTrackAndSourceTrackEvents = (track) => {
+        let trackUnsubscribe;
+        let sourceTrackUnsubscribe;
+        if (track.track) {
+            trackUnsubscribe = subscribeTrackEvents(track.track);
+            if (track.source.track && track.source.track !== track.track) {
+                sourceTrackUnsubscribe = subscribeTrackEvents(track.source.track);
+            }
+        }
+        return () => {
+            trackUnsubscribe?.();
+            sourceTrackUnsubscribe?.();
+        };
     };
-    const getExpectedAudioInput = createMemorizedGetExpectedInput();
-    const getExpectedVideoInput = createMemorizedGetExpectedInput();
-    const muteTrack = (kind) => (muted) => {
-        const { muteAudio, muteVideo, stream } = getMedia();
-        const mute = kind === 'audio' ? muteAudio : muteVideo;
-        if (mute) {
-            return mute(muted);
+    const trackSubscriptions = new Map(mediaInit.tracks.flatMap(track => {
+        if (track.track) {
+            return [
+                [track.track, subscribeTrackAndSourceTrackEvents(track)],
+            ];
         }
-        return muteStreamTrack(stream)(muted, kind);
+        return [];
+    }));
+    const getConstraints = () => {
+        const audio = props.audioTrack?.getConstraints() ?? mediaInit.constraints.audio;
+        const video = props.videoTrack?.getConstraints() ?? mediaInit.constraints.video;
+        return { audio: audio, video: video };
     };
-    const release = () => {
-        const { release, stream } = getMedia();
-        if (release) {
-            return release();
+    let unsubscribe = onDevicesChanged.add(devices => {
+        props.devices = devices;
+    });
+    const muteTrack = (track, mute) => {
+        const previousMuteState = track.muted;
+        const previousEnabledState = track.track?.enabled;
+        track.mute(mute);
+        const currentMuteState = track.muted;
+        const currentEnabledState = track.track?.enabled;
+        if (track.track &&
+            previousEnabledState !== undefined &&
+            currentEnabledState !== undefined &&
+            previousEnabledState !== currentEnabledState) {
+            mediaInit.signals?.onStreamTrackEnabled?.emit(track.track);
+        }
+        if (previousMuteState !== currentMuteState) {
+            mediaInit.signals?.[track.kind === 'audioinput'
+                ? 'onAudioMuteStateChanged'
+                : 'onVideoMuteStateChanged']?.emit(currentMuteState);
         }
-        return new Promise(resolve => {
-            stopMediaStream(stream);
-            resolve();
-        });
     };
     return {
-        get constraints() {
-            return props.constraints;
+        get id() {
+            return props.stream.id;
+        },
+        get active() {
+            return !!props.stream.active;
         },
         get devices() {
             return props.devices;
         },
-        set devices(newDevices) {
-            props.devices = newDevices;
-        },
         get stream() {
-            return getMedia().stream;
+            return props.stream;
         },
         get expectedAudioInput() {
-            const media = getMedia();
-            return getExpectedAudioInput(props.constraints?.audio, () => ({
-                devices: media.devices?.filter(isAudioInput) ?? [],
-                input: media.audioInput,
-            }));
+            return props.audioTrack?.expectedInput;
         },
         get expectedVideoInput() {
-            const media = getMedia();
-            return getExpectedVideoInput(props.constraints?.video, () => ({
-                devices: media.devices?.filter(isVideoInput) ?? [],
-                input: media.videoInput,
-            }));
-        },
-        get rawStream() {
-            const { rawStream, stream } = getMedia();
-            return rawStream ?? stream;
+            return props.videoTrack?.expectedInput;
         },
         get audioInput() {
-            return getMedia().audioInput;
+            return props.audioTrack?.input;
         },
         get videoInput() {
-            return getMedia().videoInput;
+            return props.videoTrack?.input;
         },
         get status() {
             return props.status;
         },
         set status(status) {
-            props.status = status;
-            onSetStatus?.(status);
-        },
-        set constraints(value) {
-            props.constraints = value;
+            if (props.status !== status) {
+                props.status = status;
+                mediaInit.signals?.onStatusChanged?.emit(status);
+            }
         },
         get audioMuted() {
-            return isMuted(getMedia().stream?.getAudioTracks());
+            return props.audioTrack?.muted;
         },
         get videoMuted() {
-            return isMuted(getMedia().stream?.getVideoTracks());
+            return props.videoTrack?.muted;
+        },
+        getConstraints,
+        getOriginalConstraints() {
+            return props.originalConstraints;
+        },
+        isAudioInputUnavailable() {
+            return (mediaInit.permission.audio === 'granted' &&
+                props.devices.size('audioinput') === 0);
+        },
+        isVideoInputUnavailable() {
+            return (mediaInit.permission.video === 'granted' &&
+                props.devices.size('videoinput') === 0);
+        },
+        setOriginalConstraints(constraints) {
+            props.originalConstraints = constraints;
+        },
+        requestedAudio() {
+            return (Boolean(props.audioTrack?.track) ||
+                Boolean(props.originalConstraints.audio));
+        },
+        requestedVideo() {
+            return (Boolean(props.videoTrack?.track) ||
+                Boolean(props.originalConstraints.video));
+        },
+        muteAudio(mute) {
+            if (!props.audioTrack) {
+                return;
+            }
+            muteTrack(props.audioTrack, mute);
+        },
+        muteVideo(mute) {
+            if (!props.videoTrack) {
+                return;
+            }
+            muteTrack(props.videoTrack, mute);
         },
-        muteAudio: muteTrack('audio'),
-        muteVideo: muteTrack('video'),
         applyConstraints: async (constraints) => {
-            const { stream, applyConstraints: prevApplyConstraints } = getMedia();
-            if (prevApplyConstraints) {
-                return await prevApplyConstraints(constraints);
+            await Promise.all([
+                typeof constraints.audio !== 'object'
+                    ? Promise.resolve()
+                    : props.audioTrack?.applyConstraints(constraints.audio),
+                typeof constraints.video !== 'object'
+                    ? Promise.resolve()
+                    : props.videoTrack?.applyConstraints(constraints.video),
+            ]);
+        },
+        async release() {
+            unsubscribe?.();
+            unsubscribe = undefined;
+            trackSubscriptions.forEach(unsubscribe => unsubscribe());
+            trackSubscriptions.clear();
+            await Promise.all([
+                props.audioTrack?.release(),
+                props.videoTrack?.release(),
+            ]);
+        },
+        getSettings: () => ({
+            audio: props.audioTrack?.getSettings(),
+            video: props.videoTrack?.getSettings(),
+        }),
+        clone() {
+            const tracks = [props.audioTrack, props.videoTrack].flatMap(track => {
+                if (!track?.source) {
+                    return [];
+                }
+                const cloned = track.source.clone();
+                // Restore the enabled state for all cloned track
+                cloned.mute(false);
+                return cloned;
+            });
+            const stream = this.stream &&
+                new MediaStream(tracks.flatMap(track => (track.track ? [track.track] : [])));
+            const clonedMedia = buildMedia({
+                tracks,
+                devices: this.devices,
+                status: this.status,
+                stream,
+                constraints: this.getConstraints(),
+                originalConstraints: this.getOriginalConstraints(),
+                permission: mediaInit.permission,
+            });
+            return clonedMedia;
+        },
+        getTracks() {
+            return [props.audioTrack, props.videoTrack].flatMap(track => track ? [track] : []);
+        },
+        getAudioTracks() {
+            return props.audioTrack ? [props.audioTrack] : [];
+        },
+        getVideoTracks() {
+            return props.videoTrack ? [props.videoTrack] : [];
+        },
+        addTrack(track) {
+            switch (track.kind) {
+                case 'audioinput':
+                    if (track.id === props.audioTrack?.id) {
+                        return;
+                    }
+                    props.audioTrack = track;
+                    break;
+                case 'videoinput':
+                    if (track.id === props.videoTrack?.id) {
+                        return;
+                    }
+                    props.videoTrack = track;
+                    break;
+                default:
+                    break;
+            }
+            if (track.track) {
+                props.stream.addTrack(track.track);
+                if (!trackSubscriptions.has(track.track)) {
+                    trackSubscriptions.set(track.track, subscribeTrackAndSourceTrackEvents(track));
+                }
+                mediaInit.signals?.onAddTrack?.emit(track.track);
+                props.stream.dispatchEvent(new MediaStreamTrackEvent('addtrack', { track: track.track }));
+            }
+        },
+        removeTrack(track) {
+            let removed = false;
+            if (track.id === props.audioTrack?.id) {
+                props.audioTrack = undefined;
+                removed = true;
             }
-            return await applyConstraints(stream?.getTracks(), constraints);
-        },
-        release,
-        getSettings: () => {
-            const { getSettings, stream } = getMedia();
-            if (!stream) {
-                return {
-                    audio: [],
-                    video: [],
-                };
+            if (track.id === props.videoTrack?.id) {
+                props.videoTrack = undefined;
+                removed = true;
             }
-            if (getSettings) {
-                return getSettings();
+            if (removed && track.track) {
+                props.stream.removeTrack(track.track);
+                trackSubscriptions.get(track.track)?.();
+                trackSubscriptions.delete(track.track);
+                mediaInit.signals?.onRemoveTrack?.emit(track.track);
+                props.stream.dispatchEvent(new MediaStreamTrackEvent('removetrack', {
+                    track: track.track,
+                }));
             }
+        },
+        toJSON() {
             return {
-                audio: stream
-                    .getAudioTracks()
-                    .map(track => track.getSettings()),
-                video: stream
-                    .getVideoTracks()
-                    .map(track => track.getSettings()),
+                constraints: this.getConstraints(),
+                devices: this.devices,
+                stream: this.stream,
+                audioInput: this.audioInput,
+                videoInput: this.videoInput,
+                expectedAudioInput: this.expectedAudioInput,
+                expectedVideoInput: this.expectedVideoInput,
+                status: this.status,
+                audioMuted: this.audioMuted,
+                videoMuted: this.videoMuted,
             };
         },
-        toJSON: () => toJSON(getMedia()),
     };
 };
-/**
- * Clone the media from the rawStream (if any), otherwise, stream
- */
-export const cloneMedia = async (media) => {
-    const stream = (media.rawStream ?? media.stream)?.clone();
-    // Restore the enabled state for all cloned track
-    stream?.getTracks().forEach(track => (track.enabled = true));
-    const { audio, video } = media.getSettings();
-    const clonedMedia = buildMedia(() => ({
-        stream,
-        constraints: media?.constraints,
-        devices: media?.devices,
-        status: media?.status,
-        rawStream: stream,
-        audioInput: media?.audioInput,
-        videoInput: media?.videoInput,
-        getSettings: () => ({ audio, video }),
-    }));
-    return Promise.resolve(clonedMedia);
-};
 /**
  * Shallow copy the provided object and override with provided overriding
  *
@@ -246,28 +499,8 @@ export const getDevicesChanges = (prev, next) => {
     const trackChanges = createTrackDevicesChanges(prev);
     return trackChanges(next);
 };
-/**
- * Apply Extended constraints on top of the original
- *
- * @param media - The media from the media pipeline
- * @param applyExtended - The function to be called when the previous
- * `applyConstraints` is done
- */
-export const applyExtendedConstraints = (media, applyExtended) => 
-/**
- * Apply constraints
- * @param constraints - The constraints to be applied to the media
- */
-async (constraints) => {
-    await media.applyConstraints(constraints);
-    if (!isOverConstrained(media.status)) {
-        await applyExtended(constraints);
-    }
-};
 export const AUDIO_SETTINGS_KEYS = [
     'denoise',
-    'vad',
-    'asd',
     'contentHint',
 ];
 export const VIDEO_SETTINGS_KEYS = [
@@ -279,8 +512,6 @@ export const VIDEO_SETTINGS_KEYS = [
     'edgeBlurAmount',
     'maskCombineRatio',
     'backgroundImageUrl',
-    'width',
-    'height',
     'contentHint',
 ];
 export const MIXING_SETTINGS_KEYS = [
@@ -314,24 +545,44 @@ export const hasSettingsChanged = (keysToLookFor) => {
         return cache.result;
     };
 };
-export const toJSON = (media) => {
-    return {
-        constraints: media.constraints,
-        devices: media.devices,
-        stream: media.stream,
-        rawStream: media.rawStream,
-        audioInput: media.audioInput,
-        videoInput: media.videoInput,
-        expectedAudioInput: media.expectedAudioInput,
-        expectedVideoInput: media.expectedVideoInput,
-        status: media.status,
-        audioMuted: media.audioMuted,
-        videoMuted: media.videoMuted,
+export const diffSettings = (keysToLookFor) => {
+    const cache = {};
+    return (settingsA, settingsB) => {
+        // Same as before
+        if (cache.settingsA === settingsA && cache.settingsB === settingsB) {
+            return cache.diff;
+        }
+        cache.settingsA = settingsA;
+        cache.settingsB = settingsB;
+        // Nothing changed
+        if (settingsA === settingsB) {
+            cache.diff = undefined;
+            return cache.diff;
+        }
+        if (settingsA === undefined || settingsB === undefined) {
+            cache.diff = settingsB;
+            return cache.diff;
+        }
+        for (const key of keysToLookFor) {
+            if (settingsA[key] !== settingsB[key]) {
+                if (cache.diff === undefined) {
+                    cache.diff = {};
+                }
+                // @ts-expect-error --- Type issue and need to be fixed when we have time
+                cache.diff[key] = settingsB[key];
+            }
+        }
+        return cache.diff;
     };
 };
-export const wrapToJSON = (media) => {
-    media.toJSON = () => toJSON(media);
-    return media;
+export const mergeSettings = (settingsA, settingsB) => {
+    if (settingsA === undefined) {
+        return settingsB;
+    }
+    if (settingsB === undefined) {
+        return settingsA;
+    }
+    return { ...settingsA, ...settingsB };
 };
 /**
  * A function to get the blur kernel size of image height
@@ -370,3 +621,54 @@ export const hasPtzFeature = () => {
         hasOwn(supports, 'tilt') &&
         hasOwn(supports, 'zoom'));
 };
+export const refineMediaConstraints = (state) => {
+    switch (state.permission) {
+        case 'denied':
+            return false;
+        case 'granted': {
+            const requestNeeded = shouldRequestDevice({
+                kind: state.kind,
+                permission: state.permission,
+                currentDevices: state.currentDevices,
+                request: state.request,
+                tracks: state.currentMediaTracks.flatMap(track => track.source?.track ? [track.source.track] : []),
+            });
+            if (requestNeeded || state.force) {
+                return state.request;
+            }
+            if (state.request) {
+                // We already have all we need, skip the request
+                return undefined;
+            }
+            return state.request;
+        }
+        case 'prompt':
+        default:
+            return state.request;
+    }
+};
+export const createMediaProcessor = ({ audioProcessors, videoProcessors, onProcessingError, }) => {
+    const processAudioTrack = createTrackProcessingPipeline(audioProcessors);
+    const processVideoTrack = createTrackProcessingPipeline(videoProcessors);
+    return async (newTracks) => {
+        const processTrack = async (track) => {
+            try {
+                switch (track.kind) {
+                    case 'audioinput':
+                        return await processAudioTrack(track);
+                    case 'videoinput':
+                        return await processVideoTrack(track);
+                    default:
+                        assert(false, `Unexpected track kind: ${track.kind}`);
+                }
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    onProcessingError?.(error, track);
+                }
+                return track;
+            }
+        };
+        return await Promise.all(newTracks.map(track => processTrack(track)));
+    };
+};