@pexip/media 20.1.0 → 20.3.0

package/CHANGELOG.md

@@ -1,5 +1,84 @@
 # @pexip/media
 
+## 20.3.0
+
+### Minor Changes
+
+- 69d6be4: Refactor `MediaTrack` to decouple system/hardware mute from mute
+
+  - Add `stopped` attributes to `MediaTrack` to indicate the track `live` or
+    `ended`
+  - Add `suspended` attributes to
+    `MediaTrack to indicate the track is being system/hardware muted`
+  - Add signal supports to `MediaTrack` to be able to subscribe track related
+    signals
+  - Implement Two-hand control to secure mute consistency
+
+    When there is `muted` event from `MediaStreamTrack`, the track will follow
+    the event to set the `enabled` attribute to `false` to avoid any
+    possibilities of leaking the local media to remote parties. When the
+    `unmuted` event is triggered, it depends on whether the `enabled` attribute
+    is set before the `muted` event or not to unmute the track.
+
+  Breaking changes:
+
+  - Replace `MediaStreamTrack` related signal with the new `MediaTrack` signals
+
+    - `onStreamTrackEnded` -> `onMediaTrackStopped`
+    - `onStreamTrackMuted` -> `onMediaTrackSuspended`
+    - `onStreamTrackUnmuted` -> `onMediaTrackResumed`
+    - `onStreamTrackEnabled` -> `onMediaTrackMuted`
+    - `onAudioMuteStateChanged` -> `onMediaTrackMuted`
+    - `onVideoMuteStateChanged` -> `onMediaTrackMuted`
+
+### Patch Changes
+
+- f8a8159: Fix Subsequant mute/unmute events handling
+- e347770: Handle suspended state fro preview controller
+- 0a375c7: Delay stopping video track to ensure last frame being black
+- Updated dependencies [69d6be4]
+- Updated dependencies [adc1a50]
+  - @pexip/media-control@20.3.0
+  - @pexip/utils@17.0.1
+  - @pexip/media-processor@20.3.0
+  - @pexip/signal@16.9.0
+
+## 20.2.0
+
+### Minor Changes
+
+- 574cf03: Adjusts blur passes based on processing height:
+
+  - `getBlurKernelSize` can now take `lowestProcessingHeight` so that the blur
+    passes are adjusted compared to the lowest processing height used by the
+    consumer. This fixes an issue with different blur amount being applied to
+    frames of different resolutions.
+  - background blur amount is updated every time processing dimensions are
+    updated.
+
+- be12a15: Add `getDefaultConstraints` and rename `mediaSignals` to
+  `mainMediaSignal`
+
+  - Add `getDefaultConstraints` to be consistent to the main one
+  - Rename `mediaSignals` to `mainMediaSignal`
+  - Fix `Media['clone']` to avoid interfering the original pipeline
+
+- b4c3bad: Stop camera as Mute
+
+  - Decouple updatingMedia to updatingAudio and updatingVideo
+  - Stop camera when mute, and re-request the same camera when unmute
+
+- 752005c: Release the track when providing false constraints independently
+
+### Patch Changes
+
+- Updated dependencies [f5e5b51]
+- Updated dependencies [6fddc11]
+  - @pexip/media-processor@20.2.0
+  - @pexip/signal@16.9.0
+  - @pexip/media-control@20.2.0
+  - @pexip/utils@17.0.0
+
 ## 20.1.0
 
 ### Minor Changes

package/dist/audioMixingProcessor.d.ts

@@ -1,6 +1,6 @@
 import type { MediaDeviceRequest } from '@pexip/media-control';
 import type { AudioGraph, AudioNodeInit } from '@pexip/media-processor';
-import type { TrackProcessor } from './types';
+import type { MediaSignals, TrackProcessor } from './types';
 interface AudioStreamProcessorProps {
     mixWithAdditionalMedia?: boolean;
     merger?: AudioNodeInit<ChannelMergerNode, ChannelMergerNode>;
@@ -12,7 +12,7 @@ type FeaturePropKeys = (typeof FEATURE_KEYS)[number];
 type FeatureProps = Pick<AudioStreamProcessorProps, FeaturePropKeys>;
 export declare const updateFeatureProps: (constraints: MediaDeviceRequest["audio"], props: FeatureProps) => FeatureProps;
 /**
- * Create a Audio Mixing Processor and will own the stream passed-in
+ * Create an Audio Mixing Processor and will own the stream passed-in
  */
-export declare const createAudioMixingProcess: (getCurrentMedia: () => MediaStream | undefined, label?: "AudioMixingProcessor") => TrackProcessor;
+export declare const createAudioMixingProcess: (getCurrentMedia: () => MediaStream | undefined, signals?: MediaSignals, label?: "AudioMixingProcessor") => TrackProcessor;
 export {};

package/dist/audioMixingProcessor.js

@@ -2,7 +2,7 @@ import { extractConstraintsWithKeys } from '@pexip/media-control';
 import { isEmpty, assert } from '@pexip/utils';
 import { createAudioGraph, createAudioGraphProxy, createChannelMergerGraphNode, createStreamDestinationGraphNode, createStreamSourceGraphNode, resumeAudioOnUnmute, } from '@pexip/media-processor';
 import { logger } from './logger';
-import { createMediaTrack, isTrackMuted } from './utils';
+import { createMediaTrack } from './utils';
 import { PROCESSOR_LABELS } from './constants';
 const FEATURE_KEYS = ['mixWithAdditionalMedia'];
 const getAudioConstraints = extractConstraintsWithKeys(FEATURE_KEYS);
@@ -19,9 +19,9 @@ export const updateFeatureProps = (constraints, props) => {
     }, {});
 };
 /**
- * Create a Audio Mixing Processor and will own the stream passed-in
+ * Create an Audio Mixing Processor and will own the stream passed-in
  */
-export const createAudioMixingProcess = (getCurrentMedia, label = PROCESSOR_LABELS.AudioMixingProcessor) => {
+export const createAudioMixingProcess = (getCurrentMedia, signals, label = PROCESSOR_LABELS.AudioMixingProcessor) => {
     const props = {};
     return async (prevMediaTrack) => {
         updateFeatureProps(prevMediaTrack.getConstraints(), props);
@@ -154,12 +154,12 @@ export const createAudioMixingProcess = (getCurrentMedia, label = PROCESSOR_LABE
             expectedInput: prevMediaTrack.expectedInput,
             track,
             overrideMute: true,
-            mute: toMute => {
-                prevMediaTrack.mute(toMute);
+            mute: (toMute, _self, soft) => {
                 for (const track of mainSource.node?.mediaStream.getAudioTracks() ??
                     []) {
                     track.enabled = !toMute;
                 }
+                prevMediaTrack.mute(toMute, soft);
             },
             get muted() {
                 return (
@@ -168,11 +168,12 @@ export const createAudioMixingProcess = (getCurrentMedia, label = PROCESSOR_LABE
                 !!prevMediaTrack.muted ||
                     mainSource.node?.mediaStream
                         .getAudioTracks()
-                        .some(isTrackMuted));
+                        .some(track => track.enabled === false));
             },
             constraints: prevMediaTrack.getConstraints(),
             applyConstraints,
             release,
+            signals,
             getSettings: () => {
                 const mixWithAdditionalMedia = !!props.mixWithAdditionalMedia;
                 const contentHint = track.contentHint ?? '';

package/dist/audioProcessor.d.ts

@@ -1,6 +1,6 @@
-import type { AudioGraphOptions, AudioNodeInit, ThrottleOptions, DenoiseWorkletNodeInit, AnalyzerNodeInit, AudioGraph } from '@pexip/media-processor';
+import type { AnalyzerNodeInit, AudioGraph, AudioGraphOptions, AudioNodeInit, DenoiseWorkletNodeInit, ThrottleOptions } from '@pexip/media-processor';
 import type { MediaDeviceRequest } from '@pexip/media-control';
-import type { TrackProcessor, DenoiseParams, AudioContentHint } from './types';
+import type { AudioContentHint, DenoiseParams, MediaSignals, TrackProcessor } from './types';
 type AudioNodeInits = AudioNodeInit[];
 /**
  * A function to be called to create the AudioNodes needed for the graph
@@ -60,6 +60,7 @@ interface AudioProcessOptions {
      */
     silentThreshold?: number;
     label?: string;
+    signals?: MediaSignals;
 }
 interface AudioStreamProcessorProps {
     audioGraphOptions?: AudioGraphOptions;
@@ -80,7 +81,7 @@ type FeaturePropKeys = (typeof FEATURE_KEYS)[number];
 type FeatureProps = Pick<AudioStreamProcessorProps, FeaturePropKeys>;
 export declare const updateFeatureProps: (constraints: MediaDeviceRequest["audio"], props: FeatureProps) => FeatureProps;
 /**
- * Create a Audio Stream Processor and will own the stream passed-in
+ * Create an Audio Stream Processor and will own the stream passed-in
  */
-export declare const createAudioStreamProcess: ({ analyzerUpdateFrequency, audioGraphOptions, audioSignalDetectionDuration, clock, createNodes, denoiseParams, fftSize, onAudioSignalDetected, onVoiceActivityDetected, shouldEnable, silentThreshold, throttleMs, label, }: AudioProcessOptions & ThrottleOptions) => TrackProcessor;
+export declare const createAudioStreamProcess: ({ analyzerUpdateFrequency, audioGraphOptions, audioSignalDetectionDuration, clock, createNodes, denoiseParams, fftSize, onAudioSignalDetected, onVoiceActivityDetected, shouldEnable, signals, silentThreshold, throttleMs, label, }: AudioProcessOptions & ThrottleOptions) => TrackProcessor;
 export {};

package/dist/audioProcessor.js

@@ -1,6 +1,6 @@
 import { extractConstraintsWithKeys } from '@pexip/media-control';
 import { createQueue, isEmpty, assert } from '@pexip/utils';
-import { createAudioGraph, createAudioGraphProxy, createStreamSourceGraphNode, createStreamDestinationGraphNode, createAnalyzerSubscribableGraphNode, createDenoiseWorkletGraphNode, createAudioSignalDetector, createVADetector, createVoiceDetectorFromTimeData, createVoiceDetectorFromProbability, avg, } from '@pexip/media-processor';
+import { avg, createAnalyzerSubscribableGraphNode, createAudioGraph, createAudioGraphProxy, createAudioSignalDetector, createDenoiseWorkletGraphNode, createStreamDestinationGraphNode, createStreamSourceGraphNode, createVADetector, createVoiceDetectorFromProbability, createVoiceDetectorFromTimeData, } from '@pexip/media-processor';
 import { PROCESSOR_LABELS } from './constants';
 import { logger } from './logger';
 import { isAudioContentHint } from './typeGuard';
@@ -54,12 +54,12 @@ export const updateFeatureProps = (constraints, props) => {
     }, {});
 };
 /**
- * Create a Audio Stream Processor and will own the stream passed-in
+ * Create an Audio Stream Processor and will own the stream passed-in
  */
 export const createAudioStreamProcess = ({ analyzerUpdateFrequency = 0.5, // 0.5 Hz
 audioGraphOptions, audioSignalDetectionDuration = 4.0, // 4 seconds
 clock, createNodes, denoiseParams, fftSize = 2048, // FFT size
-onAudioSignalDetected, onVoiceActivityDetected, shouldEnable, silentThreshold = 10.0 / 32767, // At least one LSB 16-bit data (compare is on absolute value).
+onAudioSignalDetected, onVoiceActivityDetected, shouldEnable, signals, silentThreshold = 10.0 / 32767, // At least one LSB 16-bit data (compare is on absolute value).
 throttleMs = 3000, // 3 seconds
 label = PROCESSOR_LABELS.AudioProcessor, }) => {
     const props = {
@@ -198,11 +198,6 @@ label = PROCESSOR_LABELS.AudioProcessor, }) => {
             props.analyzer = undefined;
             props.audioGraph = undefined;
         };
-        const mute = (mute) => {
-            if (track) {
-                track.enabled = !mute;
-            }
-        };
         return createMediaTrack({
             label,
             kind: 'audioinput',
@@ -210,9 +205,18 @@ label = PROCESSOR_LABELS.AudioProcessor, }) => {
             previousMediaTrack: prevMediaTrack,
             input: prevMediaTrack.input,
             expectedInput: prevMediaTrack.expectedInput,
-            mute,
+            overrideMute: true,
+            mute(toMute) {
+                if (track) {
+                    track.enabled = !toMute;
+                }
+            },
+            get muted() {
+                return !track.enabled;
+            },
             track,
             release,
+            signals,
             applyConstraints: async (constraints) => {
                 if (isEmpty(constraints)) {
                     return;

package/dist/media.d.ts

@@ -19,4 +19,4 @@ export declare const createMediaUpdater: ({ getUserMedia, getCurrentDevices, sho
  *
  * @param options - @see MediaOptions
  */
-export declare const createMedia: ({ getMuteState, signals, audioProcessors, videoProcessors, getDefaultConstraints, }: MediaOptions) => MediaController;
+export declare const createMedia: ({ getMuteState, signals, audioProcessors, videoProcessors, stopVideoTrackAsMute, getDefaultConstraints, }: MediaOptions) => MediaController;

package/dist/media.js

@@ -1,4 +1,4 @@
-import { createIndexedDevices, createStreamTrackEventSubscriptions, getDevices, getInputDevicePermissionState, isIndexedDevices, isRequestedResolution, mergeConstraints, } from '@pexip/media-control';
+import { createIndexedDevices, getDevices, getInputDevicePermissionState, isIndexedDevices, isRequestedResolution, mergeConstraints, } from '@pexip/media-control';
 import { createAsyncQueue, isEmpty, assert } from '@pexip/utils';
 import { internalSignals } from './signals';
 import { UserMediaStatus } from './types';
@@ -15,27 +15,35 @@ export const createMediaUpdater = ({ getUserMedia, getCurrentDevices, shouldDisc
     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) {
+        const releaseAudio = constraints.audio === false || permission.audio === 'denied';
+        const releaseVideo = constraints.video === false || permission.video === 'denied';
+        if (releaseAudio || releaseVideo) {
+            // Release related
             for (const track of currentMedia?.getTracks() ?? []) {
-                await track.release();
-                currentMedia?.removeTrack(track);
+                if ((track.kind === 'audioinput' && releaseAudio) ||
+                    (track.kind === 'videoinput' && releaseVideo)) {
+                    await track.release();
+                    currentMedia?.removeTrack(track);
+                }
+            }
+            // When both are true, there is nothing to request
+            if (releaseAudio && releaseVideo) {
+                currentMedia?.setOriginalConstraints(constraints);
+                const media = currentMedia ??
+                    buildMedia({
+                        constraints,
+                        permission,
+                        devices: currentDevices,
+                        status: permission.audio === 'denied' &&
+                            permission.video === 'denied'
+                            ? UserMediaStatus.PermissionsRejected
+                            : UserMediaStatus.PermissionsGranted,
+                        stream: undefined,
+                        signals,
+                        tracks: [],
+                    });
+                return onMediaTracksChanged(media, []);
             }
-            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, {});
@@ -206,9 +214,20 @@ const createMediaPropsHandler = (signals) => ({
                 }
                 return true;
             }
-            case 'updatingMedia': {
+            case 'updatingAudio': {
+                if (target[p] === value) {
+                    return true;
+                }
+                const result = Reflect.set(target, p, value);
+                signals?.onUpdatingAudio?.emit(value);
+                return result;
+            }
+            case 'updatingVideo': {
+                if (target[p] === value) {
+                    return true;
+                }
                 const result = Reflect.set(target, p, value);
-                signals?.onUpdatingMedia?.emit(value);
+                signals?.onUpdatingVideo?.emit(value);
                 return result;
             }
             default: {
@@ -223,11 +242,12 @@ const createMediaPropsHandler = (signals) => ({
  *
  * @param options - @see MediaOptions
  */
-export const createMedia = ({ getMuteState, signals, audioProcessors, videoProcessors, getDefaultConstraints = () => ({}), }) => {
+export const createMedia = ({ getMuteState, signals, audioProcessors, videoProcessors, stopVideoTrackAsMute = () => true, getDefaultConstraints = () => ({}), }) => {
     const _props = {
         devices: createIndexedDevices([]),
         discardMedia: false,
-        updatingMedia: false,
+        updatingAudio: false,
+        updatingVideo: false,
     };
     const props = new Proxy(_props, createMediaPropsHandler(signals));
     const queue = createAsyncQueue({
@@ -263,28 +283,6 @@ export const createMedia = ({ getMuteState, signals, audioProcessors, videoProce
         props.devices = createIndexedDevices(await getDevices());
         return props.devices;
     };
-    const syncMuteState = (tracks) => {
-        const inputMuted = getMuteState();
-        for (const track of tracks) {
-            switch (track.kind) {
-                case 'audioinput': {
-                    track.mute(inputMuted.audio);
-                    // FIXME: this can fire too often, but we want to make sure we signal initial state as well.
-                    // We should only fire this when needed.
-                    signals.onAudioMuteStateChanged?.emit(track.muted);
-                    break;
-                }
-                case 'videoinput':
-                    track.mute(inputMuted.video);
-                    // FIXME: this can fire too often, but we want to make sure we signal initial state as well.
-                    // We should only fire this when needed.
-                    signals.onVideoMuteStateChanged?.emit(track.muted);
-                    break;
-                default:
-                    break;
-            }
-        }
-    };
     const processMedia = createMediaProcessor({
         audioProcessors,
         videoProcessors,
@@ -304,19 +302,22 @@ export const createMedia = ({ getMuteState, signals, audioProcessors, videoProce
         },
     });
     const getUserMediaProcess = createGetUserMediaProcess({
-        getUserMedia: requestUserMediaWithRetry(getCurrentDevices),
         getCurrentDevices,
+        getUserMedia: requestUserMediaWithRetry(getCurrentDevices),
         signals,
+        stopVideoTrackAsMute,
+        updateMedia: constraints => updateMedia(constraints),
     });
     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) {
+                if (originTrack.muted !== undefined) {
+                    track.mute(originTrack.muted);
+                }
                 media.removeTrack(originTrack);
                 media.addTrack(track);
             }
@@ -329,19 +330,12 @@ export const createMedia = ({ getMuteState, signals, audioProcessors, videoProce
         shouldDiscardMedia: () => props.discardMedia,
         getDefaultConstraints,
         onMediaTracksChanged: (media, tracks) => {
-            // Sync mute state to input tracks
-            syncMuteState(tracks);
+            const inputMuted = getMuteState();
             for (const track of tracks) {
-                if (track.track) {
-                    const unsubscribe = createStreamTrackEventSubscriptions(track.track, {
-                        ended: track => {
-                            signals.onStreamTrackEnded?.emit(track);
-                            unsubscribe();
-                        },
-                        mute: signals.onStreamTrackMuted?.emit,
-                        unmute: signals.onStreamTrackUnmuted?.emit,
-                    });
-                }
+                // Sync mute state to input tracks
+                track.mute(track.kind === 'audioinput'
+                    ? inputMuted.audio
+                    : inputMuted.video);
             }
             logger.debug({ media, tracks }, 'Update media tracks');
             props.media = media;
@@ -359,12 +353,24 @@ export const createMedia = ({ getMuteState, signals, audioProcessors, videoProce
      * @param constraints - @see MediaDeviceRequest
      */
     const updateMedia = async (constraints) => {
+        const updateAudio = constraints.audio !== undefined;
+        const updateVideo = constraints.video !== undefined;
         try {
-            props.updatingMedia = true;
+            if (updateAudio) {
+                props.updatingAudio = true;
+            }
+            if (updateVideo) {
+                props.updatingVideo = true;
+            }
             await updateMediaProcess(constraints, props.media);
         }
         finally {
-            props.updatingMedia = false;
+            if (updateAudio) {
+                props.updatingAudio = false;
+            }
+            if (updateVideo) {
+                props.updatingVideo = false;
+            }
         }
     };
     const mergeMediaConstraints = (constraints) => {
@@ -424,8 +430,11 @@ export const createMedia = ({ getMuteState, signals, audioProcessors, videoProce
         navigator.mediaDevices.addEventListener('devicechange', handleDeviceChange);
     }
     return {
-        get updatingMedia() {
-            return props.updatingMedia;
+        get updatingAudio() {
+            return props.updatingAudio;
+        },
+        get updatingVideo() {
+            return props.updatingVideo;
         },
         get media() {
             return props.media;

package/dist/previewController.d.ts

@@ -1,4 +1,4 @@
-import type { IndexedDevices, MediaDeviceInfoLike, MediaDeviceRequest } from '@pexip/media-control';
+import type { IndexedDevices, InputConstraintSet, MediaDeviceInfoLike, MediaDeviceRequest } from '@pexip/media-control';
 import type { AsyncQueueOptions } from '@pexip/utils';
 import type { Media, MediaSignals, TrackProcessor, Unsubscribe } from './types';
 type EventCallback<T> = (event: T) => void;
@@ -12,30 +12,45 @@ export interface PreviewEventHandler {
     audioInputError?: EventErrorCallback;
     applyChangesError?: EventErrorCallback;
     revertChangesError?: EventErrorCallback;
-    updatingPreview?: EventCallback<boolean>;
+    audioMuted?: EventCallback<boolean | undefined>;
+    audioSuspended?: EventCallback<boolean | undefined>;
     updatingMain?: EventCallback<boolean>;
+    updatingPreviewAudio?: EventCallback<boolean>;
+    updatingPreviewVideo?: EventCallback<boolean>;
+    videoMuted?: EventCallback<boolean | undefined>;
+    videoSuspended?: EventCallback<boolean | undefined>;
     unsubscribeMain?: Unsubscribe;
 }
 export interface PreviewStreamParams {
     getCurrentDevices: () => IndexedDevices;
     getCurrentMedia: () => Media | undefined;
     updateMainStream: (request: MediaDeviceRequest) => Promise<void>;
-    mediaSignal: MediaSignals['onMediaChanged'];
+    mainMediaSignal: MediaSignals['onMediaChanged'];
+    signals: MediaSignals;
     onEnded?: () => void;
     fftSize?: number;
     queueOptions?: Partial<AsyncQueueOptions>;
     audioProcessors: TrackProcessor[];
     videoProcessors: TrackProcessor[];
+    /**
+     * Pass default constraints to use with get media wrappers
+     */
+    getDefaultConstraints?: () => {
+        audio?: InputConstraintSet | false;
+        video?: InputConstraintSet | false;
+    };
 }
 export interface PreviewControllerProps {
     media: Media | undefined;
     audioInput?: MediaDeviceInfoLike;
     videoInput?: MediaDeviceInfoLike;
-    updatingPreview: boolean;
+    updatingPreviewAudio: boolean;
+    updatingPreviewVideo: boolean;
     updatingMain: boolean;
     originalMainAudioInput?: MediaDeviceInfoLike;
     discardMedia: boolean;
     initialized: boolean;
+    signals: MediaSignals;
 }
 export interface PreviewStreamController {
     media: Media | undefined;
@@ -44,8 +59,10 @@ export interface PreviewStreamController {
     inputChanged: boolean;
     audioInput: PreviewInput;
     videoInput: PreviewInput;
-    updatingPreview: boolean;
     updatingMain: boolean;
+    updatingPreviewAudio: boolean;
+    updatingPreviewVideo: boolean;
+    updatePreviewInput(input: PreviewInput): void;
     updateAudioInput(id: string): void;
     updateVideoInput(id: string): void;
     applyChanges(force?: boolean): Promise<void>;
@@ -54,13 +71,18 @@ export interface PreviewStreamController {
     onMediaChanged(callback: EventCallback<Media>): Unsubscribe;
     onAudioInputChanged(callback: EventCallback<PreviewInput>): Unsubscribe;
     onVideoInputChanged(callback: EventCallback<PreviewInput>): Unsubscribe;
-    onUpdatingPreview(callback: EventCallback<boolean>): Unsubscribe;
+    onUpdatingPreviewAudio(callback: EventCallback<boolean>): Unsubscribe;
+    onUpdatingPreviewVideo(callback: EventCallback<boolean>): Unsubscribe;
     onUpdatingMain(callback: EventCallback<boolean>): Unsubscribe;
     onAudioInputError(callback: EventErrorCallback): Unsubscribe;
     onVideoInputError(callback: EventErrorCallback): Unsubscribe;
     onApplyChangesError(callback: EventErrorCallback): Unsubscribe;
     onRevertChangesError(callback: EventErrorCallback): Unsubscribe;
+    onAudioMuted(callback: EventCallback<boolean | undefined>): Unsubscribe;
+    onAudioSuspended(callback: EventCallback<boolean | undefined>): Unsubscribe;
+    onVideoMuted(callback: EventCallback<boolean | undefined>): Unsubscribe;
+    onVideoSuspended(callback: EventCallback<boolean | undefined>): Unsubscribe;
 }
-export declare const createPreviewStreamController: ({ getCurrentDevices, getCurrentMedia, updateMainStream, onEnded, mediaSignal, queueOptions, audioProcessors, videoProcessors, }: PreviewStreamParams) => PreviewStreamController;
+export declare const createPreviewStreamController: ({ getCurrentDevices, getCurrentMedia, updateMainStream, onEnded, mainMediaSignal, queueOptions, audioProcessors, videoProcessors, getDefaultConstraints, signals, }: PreviewStreamParams) => PreviewStreamController;
 export type CreatePreviewStreamController = typeof createPreviewStreamController;
 export {};