@pexip/media 18.5.0 → 19.1.0

package/dist/media.js

@@ -1,14 +1,103 @@
-import { subscribe, MediaEventType, MediaDeviceFailure, createStreamTrackEventSubscriptions, getDevices, isRequestedResolution, mergeConstraints, shouldRequestDevice, extractConstrainDevice, } from '@pexip/media-control';
-import { createAsyncQueue, isEmpty } from '@pexip/utils';
-import { getPermissionStatus, deriveInitialPermissionStatus, isInitialPermissions, isInitialPermissionsGranted, isVideoDeviceInUse, isDevicesInUse, isAudioDeviceInUse, } from './status';
+import { MediaEventType, createIndexedDevices, createStreamTrackEventSubscriptions, getDevices, getInputDevicePermissionState, isIndexedDevices, isRequestedResolution, mergeConstraints, subscribe, } from '@pexip/media-control';
+import { createAsyncQueue, isEmpty, assert } from '@pexip/utils';
+import { internalSignals } from './signals';
 import { UserMediaStatus } from './types';
 import { createModuleLogger, logger } from './logger';
 import { createGetUserMediaProcess, requestUserMediaWithRetry, } from './userMedia';
-import { createMediaPipeline, createMediaProcess, buildMedia, getDevicesChanges, shallowCopy, wrapToJSON, hasSettingsChanged, AUDIO_SETTINGS_KEYS, VIDEO_SETTINGS_KEYS, MIXING_SETTINGS_KEYS, applyContentHint, hasPtzFeature, } from './utils';
+import { AUDIO_SETTINGS_KEYS, MIXING_SETTINGS_KEYS, VIDEO_SETTINGS_KEYS, buildMedia, createMediaProcessor, diffSettings, getDevicesChanges, hasPtzFeature, mergeSettings, refineMediaConstraints, } from './utils';
+import { getPermissionStatus, isInitialPermissionsGranted } from './status';
 import { isMedia } from './typeGuard';
 import { updateFeatureProps as getVideoFeatures } from './videoProcessor';
 import { updateFeatureProps as getAudioFeatures } from './audioProcessor';
 import { updateFeatureProps as getMixingFeatures } from './audioMixingProcessor';
+import { GET_USER_MEDIA_TIMEOUT_MS } from './constants';
+export const createMediaUpdater = ({ getUserMedia, getCurrentDevices, shouldDiscardMedia: shouldDisgardMedia, onMediaTracksChanged, getInputDevicePermission = getInputDevicePermissionState, signals, }) => {
+    return async (constraints, currentMedia) => {
+        const currentDevices = await getCurrentDevices();
+        const permission = await getInputDevicePermission();
+        const requestNothing = !constraints.audio && !constraints.video;
+        const permissionRejected = permission.audio === 'denied' && permission.video === 'denied';
+        if (requestNothing || permissionRejected) {
+            for (const track of currentMedia?.getTracks() ?? []) {
+                await track.release();
+                currentMedia?.removeTrack(track);
+            }
+            currentMedia?.setOriginalConstraints(constraints);
+            const media = currentMedia ??
+                buildMedia({
+                    constraints,
+                    permission,
+                    devices: currentDevices,
+                    status: permissionRejected
+                        ? UserMediaStatus.PermissionsRejected
+                        : UserMediaStatus.PermissionsGranted,
+                    stream: undefined,
+                    signals,
+                    tracks: [],
+                });
+            return onMediaTracksChanged(media, []);
+        }
+        const { audio: prevAudioSettings, video: prevVideoSettings } = currentMedia?.getSettings() ?? {};
+        const videoFeatures = getVideoFeatures(constraints.video, {});
+        const audioFeatures = getAudioFeatures(constraints.audio, {});
+        const mixingFeatures = getMixingFeatures(constraints.audio, {});
+        const hasRequestedResolution = ['blur', 'overlay'].includes(videoFeatures.videoSegmentation ?? '') || // Skip when there is a render effect to modify the video
+            currentDevices.size('videoinput') === 0 || // Skip when no authorized video found
+            isRequestedResolution(constraints.video, currentMedia?.getVideoTracks().at(0)?.getSettings());
+        const audioFeaturesChanged = diffSettings(AUDIO_SETTINGS_KEYS)(prevAudioSettings, audioFeatures);
+        const videoFeaturesChanged = diffSettings(VIDEO_SETTINGS_KEYS)(prevVideoSettings, videoFeatures);
+        const mixingFeaturesChanged = diffSettings(MIXING_SETTINGS_KEYS)(prevAudioSettings, mixingFeatures);
+        const ptzFeaturesChanges = hasPtzFeature() &&
+            diffSettings(['pan', 'tilt', 'zoom'])(prevVideoSettings, videoFeatures);
+        const audioRequest = refineMediaConstraints({
+            kind: 'audioinput',
+            request: constraints.audio,
+            currentDevices,
+            permission: permission.audio,
+            currentMediaTracks: currentMedia?.getAudioTracks() ?? [],
+        });
+        const videoRequest = refineMediaConstraints({
+            kind: 'videoinput',
+            request: constraints.video,
+            currentDevices,
+            permission: permission.video,
+            currentMediaTracks: currentMedia?.getVideoTracks() ?? [],
+            force: !hasRequestedResolution || Boolean(ptzFeaturesChanges),
+        });
+        if (audioRequest !== undefined || videoRequest !== undefined) {
+            const media = await getUserMedia({
+                constraints: { audio: audioRequest, video: videoRequest },
+                originalConstraints: constraints,
+                permission,
+                currentMedia,
+            });
+            if (shouldDisgardMedia()) {
+                logger.debug('Discard media');
+                return await media.release();
+            }
+            onMediaTracksChanged(media, [
+                ...(audioRequest ? media.getAudioTracks() : []),
+                ...(videoRequest ? media.getVideoTracks() : []),
+            ]);
+        }
+        const audioDiff = constraints.audio &&
+            audioRequest === undefined &&
+            currentMedia?.getAudioTracks().at(0)
+            ? mergeSettings(audioFeaturesChanged, mixingFeaturesChanged)
+            : undefined;
+        const videoDiff = constraints.video &&
+            videoRequest === undefined &&
+            currentMedia?.getVideoTracks().at(0)
+            ? videoFeaturesChanged
+            : undefined;
+        if (audioDiff || videoDiff) {
+            await currentMedia?.applyConstraints({
+                audio: audioDiff,
+                video: videoDiff,
+            });
+        }
+    };
+};
 /**
  * Proxy handler for Media Props
  */
@@ -24,8 +113,11 @@ const createMediaPropsHandler = (signals) => ({
             return true;
         }
         if (p === 'devices') {
+            if (!isIndexedDevices(value)) {
+                return false;
+            }
             const nextDevices = value;
-            const changes = getDevicesChanges(target[p].flatMap(device => (device.label ? [device] : [])), nextDevices);
+            const changes = getDevicesChanges(target[p].get(), nextDevices.get());
             if (isEmpty(changes.found) && isEmpty(changes.lost)) {
                 return true;
             }
@@ -40,20 +132,19 @@ const createMediaPropsHandler = (signals) => ({
         }, `Update Props[${p}]`);
         switch (p) {
             case 'devices': {
-                if (!Array.isArray(value)) {
+                if (!isIndexedDevices(value)) {
                     return false;
                 }
-                const devices = value;
-                target[p] = devices;
-                signals?.onDevicesChanged?.emit(devices);
-                target.media.devices = devices;
+                target[p] = value;
+                signals?.onDevicesChanged?.emit(target[p]);
+                internalSignals.onDevicesChanged.emit(target[p]);
                 return true;
             }
             case 'media': {
                 if (!isMedia(value)) {
                     return false;
                 }
-                const currentStatus = target[p].status;
+                const currentStatus = target[p]?.status;
                 target[p] = value;
                 signals?.onMediaChanged?.emit(value);
                 if (currentStatus !== value.status) {
@@ -61,9 +152,13 @@ const createMediaPropsHandler = (signals) => ({
                 }
                 return true;
             }
+            case 'updatingMedia': {
+                const result = Reflect.set(target, p, value);
+                signals?.onUpdatingMedia?.emit(value);
+                return result;
+            }
             default: {
-                Reflect.set(target, p, value);
-                return true;
+                return Reflect.set(target, p, value);
             }
         }
     },
@@ -74,93 +169,137 @@ const createMediaPropsHandler = (signals) => ({
  *
  * @param options - @see MediaOptions
  */
-export const createMedia = ({ getMuteState, signals, mediaProcessors, getDefaultConstraints = () => ({}), }) => {
-    const initMedia = (status = UserMediaStatus.Initial, devices = [], constraints) => buildMedia(() => ({ status, devices, constraints }), signals.onStatusChanged?.emit);
+export const createMedia = ({ getMuteState, signals, audioProcessors, videoProcessors, getDefaultConstraints = () => ({}), }) => {
     const _props = {
-        devices: [],
-        media: initMedia(),
+        devices: createIndexedDevices([]),
         discardMedia: false,
+        updatingMedia: false,
     };
     const props = new Proxy(_props, createMediaPropsHandler(signals));
-    const queue = createAsyncQueue();
+    const queue = createAsyncQueue({
+        timeoutInMS: GET_USER_MEDIA_TIMEOUT_MS,
+        handleTimeout: async () => {
+            const status = UserMediaStatus.NoDevicesFound;
+            if (props.media) {
+                props.media.status = status;
+            }
+            else {
+                const permission = await getInputDevicePermissionState();
+                const devices = await getCurrentDevices();
+                props.media = buildMedia({
+                    constraints: getDefaultConstraints(),
+                    permission,
+                    devices,
+                    status: UserMediaStatus.NoDevicesFound,
+                    stream: undefined,
+                    signals,
+                    tracks: [],
+                });
+            }
+        },
+    });
     const logger = createModuleLogger({
         module: 'Media',
         props: _props,
         get mediaTracks() {
             return _props.media?.stream?.getTracks();
         },
-        get rawMediaTracks() {
-            return _props.media?.rawStream?.getTracks();
+    });
+    const getCurrentDevices = async () => {
+        if (props.devices.size()) {
+            return props.devices;
+        }
+        props.devices = createIndexedDevices(await getDevices());
+        return props.devices;
+    };
+    const syncMuteState = (tracks) => {
+        const inputMuted = getMuteState();
+        for (const track of tracks) {
+            const prevMuted = track.muted;
+            switch (track.kind) {
+                case 'audioinput': {
+                    track.mute(inputMuted.audio);
+                    if (prevMuted !== track.muted) {
+                        signals.onAudioMuteStateChanged?.emit(track.muted);
+                    }
+                    break;
+                }
+                case 'videoinput':
+                    track.mute(inputMuted.video);
+                    if (prevMuted !== track.muted) {
+                        signals.onVideoMuteStateChanged?.emit(track.muted);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+    };
+    const processMedia = createMediaProcessor({
+        audioProcessors,
+        videoProcessors,
+        onProcessingError(error, track) {
+            logger.error({ error, track }, 'Failed to process media track');
+            assert(props.media);
+            switch (track.kind) {
+                case 'audioinput':
+                    // FIXME: It should not be device-not-found error, will be fixed with https://gitlab.com/pexip/zoo/-/issues/3793
+                    props.media.status = UserMediaStatus.AudioDeviceNotFound;
+                    break;
+                case 'videoinput':
+                    // FIXME: It should not be device-not-found error, will be fixed with https://gitlab.com/pexip/zoo/-/issues/3793
+                    props.media.status = UserMediaStatus.VideoDeviceNotFound;
+                    break;
+            }
         },
     });
-    const cleanup = async () => {
-        if (isInitialPermissions(props.media.status)) {
-            props.discardMedia = true;
+    const getUserMediaProcess = createGetUserMediaProcess({
+        getUserMedia: requestUserMediaWithRetry(getCurrentDevices),
+        getCurrentDevices,
+        signals,
+    });
+    const processAndUpdateMedia = async (media, tracks) => {
+        const processedTracks = await processMedia(tracks);
+        // Sync mute state to processed tracks
+        syncMuteState(processedTracks);
+        for (const [idx, track] of processedTracks.entries()) {
+            const originTrack = tracks.at(idx);
+            assert(originTrack, 'Processed track should always has the original track in the same order');
+            // Only replace track when they are not the same
+            if (originTrack.id !== track.id) {
+                media.removeTrack(originTrack);
+                media.addTrack(track);
+            }
         }
-        // carry the most recent status over for the next time
-        const status = await deriveInitialPermissionStatus(props.media.status);
-        props.media = initMedia(status, props.devices, props.media.constraints);
     };
-    // Media Pipeline
-    const mediaPipeline = createMediaPipeline([
-        createGetUserMediaProcess(requestUserMediaWithRetry(), () => props.devices, { initialMedia: props.media }),
-        ...mediaProcessors,
-        createMediaProcess(media => {
-            // Subscribe the track event from raw stream
-            const trackSubscriptions = media.rawStream?.getTracks().map(track => createStreamTrackEventSubscriptions(track, {
-                ended: signals.onStreamTrackEnded?.emit,
-                mute: signals.onStreamTrackMuted?.emit,
-                unmute: signals.onStreamTrackUnmuted?.emit,
-            }));
-            const muteTrack = (tracks) => (muted) => {
-                const [track] = tracks;
-                const kind = track?.kind;
-                if (track && (kind === 'audio' || kind === 'video')) {
-                    media[kind === 'audio' ? 'muteAudio' : 'muteVideo'](muted);
-                    return tracks.forEach(track => {
-                        logger.debug({ trackInResult: track, intendToMute: muted }, `mute ${track.kind}`);
-                        signals.onStreamTrackEnabled?.emit(track);
+    const updateMediaProcess = createMediaUpdater({
+        signals,
+        getUserMedia: getUserMediaProcess,
+        getCurrentDevices,
+        shouldDiscardMedia: () => props.discardMedia,
+        onMediaTracksChanged: (media, tracks) => {
+            // Sync mute state to input tracks
+            syncMuteState(tracks);
+            tracks.forEach(track => {
+                if (track.track) {
+                    const unsubscribe = createStreamTrackEventSubscriptions(track.track, {
+                        ended: track => {
+                            signals.onStreamTrackEnded?.emit(track);
+                            unsubscribe();
+                        },
+                        mute: signals.onStreamTrackMuted?.emit,
+                        unmute: signals.onStreamTrackUnmuted?.emit,
                     });
                 }
-                logger.warn({ tracks, kind }, 'trying to mute but no track');
-            };
-            const muteAudio = muteTrack(media.stream?.getAudioTracks() ?? []);
-            const muteVideo = muteTrack(media.stream?.getVideoTracks() ?? []);
-            // Sync mute
-            const { audio, video } = getMuteState();
-            media.audioMuted !== undefined && muteAudio(audio);
-            media.videoMuted !== undefined && muteVideo(video);
-            const release = async () => {
-                trackSubscriptions?.forEach(unsubscribe => unsubscribe());
-                await media.release();
-                await cleanup();
-            };
-            const applyConstraints = async (constraints) => {
-                await media.applyConstraints(constraints);
-                const videoFeatures = getVideoFeatures(constraints.video, {});
-                const audioFeatures = getAudioFeatures(constraints.audio, {});
-                media.stream
-                    ?.getAudioTracks()
-                    .forEach(applyContentHint(audioFeatures.contentHint));
-                media.stream
-                    ?.getVideoTracks()
-                    .forEach(applyContentHint(videoFeatures.contentHint));
-            };
-            logger.debug({ finalAudioMute: audio, finalVideoMute: video }, 'End of media pipeline');
-            return wrapToJSON(shallowCopy(media, {
-                release,
-                muteAudio: mute => {
-                    muteAudio(mute);
-                    signals.onAudioMuteStateChanged?.emit(mute);
-                },
-                muteVideo: mute => {
-                    muteVideo(mute);
-                    signals.onVideoMuteStateChanged?.emit(mute);
-                },
-                applyConstraints,
-            }));
-        }),
-    ]);
+            });
+            props.media = media;
+            processAndUpdateMedia(media, tracks).catch((error) => {
+                if (error instanceof Error) {
+                    logger.error(error, 'Failed to process media');
+                }
+            });
+        },
+    });
     /**
      * A function to update the media only when necessary, aka the current setup
      * for the stream is different from the new constraints
@@ -168,81 +307,12 @@ export const createMedia = ({ getMuteState, signals, mediaProcessors, getDefault
      * @param constraints - @see MediaDeviceRequest
      */
     const updateMedia = async (constraints) => {
-        if (!constraints.audio && !constraints.video) {
-            throw new Error(MediaDeviceFailure.MissingConstraintsError);
-        }
-        // Check if the audio device was requested before and is currently in use by another application
-        const isTryingToRequestSameUsedAudioDevice = (isAudioDeviceInUse(props.media.status) ||
-            isDevicesInUse(props.media.status)) &&
-            props.media.expectedAudioInput?.deviceId &&
-            props.media.expectedAudioInput?.deviceId ===
-                extractConstrainDevice(constraints.audio)?.[0]?.[0]?.deviceId;
-        // Check if the video device was requested before and is currently in use by another application
-        const isTryingToRequestSameUsedVideoDevice = (isVideoDeviceInUse(props.media.status) ||
-            isDevicesInUse(props.media.status)) &&
-            props.media.expectedVideoInput?.deviceId &&
-            props.media.expectedVideoInput?.deviceId ===
-                extractConstrainDevice(constraints?.video)?.[0]?.[0]?.deviceId;
-        const shouldRequestAudio = !isTryingToRequestSameUsedAudioDevice &&
-            shouldRequestDevice(constraints.audio, props.media?.rawStream?.getAudioTracks() ?? [], props.devices.filter(device => device.kind === 'audioinput'));
-        const shouldRequestVideo = !isTryingToRequestSameUsedVideoDevice &&
-            shouldRequestDevice(constraints.video, props.media?.rawStream?.getVideoTracks() ?? [], props.devices.filter(device => device.kind === 'videoinput'));
-        const { audio: [prevAudioSettings], video: [prevVideoSettings], } = props.media.getSettings();
-        const videoFeatures = getVideoFeatures(constraints.video, {});
-        const audioFeatures = getAudioFeatures(constraints.audio, {});
-        const mixingFeatures = getMixingFeatures(constraints.audio, {});
-        const hasRequestedResolution = ['blur', 'overlay'].includes(videoFeatures.videoSegmentation ?? '') || // Skip when there is a render effect to modify the video
-            !props.devices.some(device => device.kind === 'videoinput' && device.label) || // Skip when no authorized video found
-            isTryingToRequestSameUsedVideoDevice ||
-            isRequestedResolution(constraints.video, props.media?.videoInput);
-        const audioFeaturesChanged = hasSettingsChanged(AUDIO_SETTINGS_KEYS)(prevAudioSettings, audioFeatures);
-        const videoFeaturesChanged = hasSettingsChanged(VIDEO_SETTINGS_KEYS)(prevVideoSettings, videoFeatures);
-        const mixingFeaturesChanged = hasSettingsChanged(MIXING_SETTINGS_KEYS)(prevAudioSettings, mixingFeatures);
-        const ptzFeaturesChanges = hasPtzFeature() &&
-            hasSettingsChanged(['pan', 'tilt', 'zoom'])(prevVideoSettings, videoFeatures);
-        logger.debug({
-            constraints,
-            stream: props.media.stream,
-            currentDevices: props.devices,
-            shouldRequestAudio,
-            shouldRequestVideo,
-            sameResolution: hasRequestedResolution,
-            audioFeaturesChanged,
-            videoFeaturesChanged,
-            mixingFeaturesChanged,
-        }, 'Is currently streaming requested stream');
-        if (shouldRequestAudio ||
-            shouldRequestVideo ||
-            ptzFeaturesChanges ||
-            !hasRequestedResolution ||
-            !props.media.stream) {
-            if (props.media) {
-                await props.media.release();
-            }
-            if (props.discardMedia) {
-                props.discardMedia = false;
-            }
-            const media = await mediaPipeline.execute(constraints);
-            media.stream
-                ?.getAudioTracks()
-                .forEach(applyContentHint(audioFeatures.contentHint));
-            media.stream
-                ?.getVideoTracks()
-                .forEach(applyContentHint(videoFeatures.contentHint));
-            if (props.discardMedia) {
-                logger.debug('Discard media');
-                return await media.release();
-            }
-            props.media = media;
+        try {
+            props.updatingMedia = true;
+            await updateMediaProcess(constraints, props.media);
         }
-        else if (audioFeaturesChanged ||
-            videoFeaturesChanged ||
-            mixingFeaturesChanged) {
-            props.media.constraints = constraints;
-            await props.media.applyConstraints({
-                audio: audioFeatures,
-                video: videoFeatures,
-            });
+        finally {
+            props.updatingMedia = false;
         }
     };
     const mergeMediaConstraints = (constraints) => {
@@ -265,25 +335,33 @@ export const createMedia = ({ getMuteState, signals, mediaProcessors, getDefault
     };
     const tryAndGetUserMedia = constraints => {
         queue.enqueue(async () => {
-            props.media.status = await getPermissionStatus();
-            logger.debug({ status: props.media.status }, 'Current Permission State');
-            const mergedConstraints = mergeMediaConstraints(constraints);
-            props.media.constraints = mergedConstraints;
-            props.devices = await getDevices();
-            if (!mergedConstraints.audio && !mergedConstraints.video) {
-                return;
+            const permission = await getInputDevicePermissionState();
+            const status = getPermissionStatus(permission);
+            if (isInitialPermissionsGranted(status)) {
+                await updateMedia(mergeMediaConstraints(constraints));
             }
-            if (isInitialPermissionsGranted(props.media.status)) {
-                return await updateMedia(mergedConstraints);
+            else {
+                const currentDevices = await getCurrentDevices();
+                props.media = buildMedia({
+                    constraints,
+                    permission,
+                    devices: currentDevices,
+                    status,
+                    stream: undefined,
+                    signals,
+                    tracks: [],
+                });
             }
         });
     };
     // Media Control Event handlers
     const handleNoInputs = (_availableDevices) => {
-        props.media.status = UserMediaStatus.NoDevicesFound;
+        if (props.media) {
+            props.media.status = UserMediaStatus.NoDevicesFound;
+        }
     };
     const handleDeviceChange = (devices) => {
-        props.devices = devices;
+        props.devices = createIndexedDevices(devices);
     };
     // Subscribe Media Events for devices
     subscribe(event => {
@@ -305,6 +383,9 @@ export const createMedia = ({ getMuteState, signals, mediaProcessors, getDefault
         }
     });
     return {
+        get updatingMedia() {
+            return props.updatingMedia;
+        },
         get media() {
             return props.media;
         },

package/dist/previewController.d.ts

@@ -1,6 +1,6 @@
-import type { MediaDeviceRequest, MediaDeviceInfoLike } from '@pexip/media-control';
+import type { IndexedDevices, MediaDeviceInfoLike, MediaDeviceRequest } from '@pexip/media-control';
 import type { AsyncQueueOptions } from '@pexip/utils';
-import type { Media, Unsubscribe, MediaSignals, MediaProcessor } from './types';
+import type { Media, MediaSignals, TrackProcessor, Unsubscribe } from './types';
 type EventCallback<T> = (event: T) => void;
 type EventErrorCallback = (error: Error) => void;
 export type PreviewInput = MediaDeviceInfoLike | undefined;
@@ -17,17 +17,18 @@ export interface PreviewEventHandler {
     unsubscribeMain?: Unsubscribe;
 }
 export interface PreviewStreamParams {
-    getCurrentDevices: () => MediaDeviceInfoLike[];
+    getCurrentDevices: () => IndexedDevices;
     getCurrentMedia: () => Media | undefined;
     updateMainStream: (request: MediaDeviceRequest) => Promise<void>;
     mediaSignal: MediaSignals['onMediaChanged'];
     onEnded?: () => void;
     fftSize?: number;
     queueOptions?: Partial<AsyncQueueOptions>;
-    processors: MediaProcessor[];
+    audioProcessors: TrackProcessor[];
+    videoProcessors: TrackProcessor[];
 }
 export interface PreviewControllerProps {
-    media: Media;
+    media: Media | undefined;
     audioInput?: MediaDeviceInfoLike;
     videoInput?: MediaDeviceInfoLike;
     updatingPreview: boolean;
@@ -37,7 +38,7 @@ export interface PreviewControllerProps {
     initialized: boolean;
 }
 export interface PreviewStreamController {
-    media: Media;
+    media: Media | undefined;
     audioInputChanged: boolean;
     videoInputChanged: boolean;
     inputChanged: boolean;
@@ -45,8 +46,8 @@ export interface PreviewStreamController {
     videoInput: PreviewInput;
     updatingPreview: boolean;
     updatingMain: boolean;
-    updateAudioInput(input: PreviewInput): void;
-    updateVideoInput(input: PreviewInput): void;
+    updateAudioInput(id: string): void;
+    updateVideoInput(id: string): void;
     applyChanges(force?: boolean): Promise<void>;
     revertChanges(): Promise<void>;
     cleanup: () => Promise<void>;
@@ -60,6 +61,6 @@ export interface PreviewStreamController {
     onApplyChangesError(callback: EventErrorCallback): Unsubscribe;
     onRevertChangesError(callback: EventErrorCallback): Unsubscribe;
 }
-export declare const createPreviewStreamController: ({ getCurrentDevices, getCurrentMedia, updateMainStream, onEnded, mediaSignal, queueOptions, processors, }: PreviewStreamParams) => PreviewStreamController;
+export declare const createPreviewStreamController: ({ getCurrentDevices, getCurrentMedia, updateMainStream, onEnded, mediaSignal, queueOptions, audioProcessors, videoProcessors, }: PreviewStreamParams) => PreviewStreamController;
 export type CreatePreviewStreamController = typeof createPreviewStreamController;
 export {};