@pexip/media 19.0.0 → 20.0.0

package/dist/status.d.ts

@@ -26,6 +26,7 @@ export declare const isUnknownError: UserMediaValidator;
 export declare const isInitial: UserMediaValidator;
 export declare const isInitialPermissions: UserMediaValidator;
 export declare const isInitialPermissionsNotGranted: UserMediaValidator;
+export declare const isRequestPermissionNeeded: UserMediaValidator;
 export declare const isInitialPermissionsGranted: UserMediaValidator;
 export declare const isAudioDeviceInUse: UserMediaValidator;
 export declare const isDeviceInUse: UserMediaValidator;
@@ -36,4 +37,4 @@ export declare const getPermissionStatus: ({ audio, video, }: {
     audio: PermissionState;
     video: PermissionState;
 }) => UserMediaStatus.Initial | UserMediaStatus.InitialPermissionsGranted | UserMediaStatus.InitialPermissionsNotGranted | UserMediaStatus.InitialPermissionsVideoInputDenied | UserMediaStatus.InitialPermissionsAudioInputDenied | UserMediaStatus.InitialPermissionsVideoInputGranted | UserMediaStatus.InitialPermissionsAudioInputGranted | UserMediaStatus.InitialPermissionsGrantedVideoInputDenied | UserMediaStatus.InitialPermissionsGrantedAudioInputDenied | UserMediaStatus.PermissionsRejected;
-export declare const deriveInitialPermissionStatus: (prevStatus: UserMediaStatus, getPermissionState?: (anyActiveAudioTrack?: boolean | undefined, anyActiveVideoTrack?: boolean | undefined, getDevices?: (() => Promise<MediaDeviceInfo[]>) | undefined) => Promise<import("@pexip/media-control").InputDevicePermission>) => Promise<UserMediaStatus>;
+export declare const deriveInitialPermissionStatus: (prevStatus: UserMediaStatus, getPermissionState?: (anyActiveAudioTrack?: boolean, anyActiveVideoTrack?: boolean, getDevices?: () => Promise<MediaDeviceInfo[]>) => Promise<import("@pexip/media-control").InputDevicePermission>) => Promise<UserMediaStatus>;

package/dist/status.js

@@ -110,10 +110,18 @@ export const isInitialPermissionsNotGranted = status => [
     UserMediaStatus.InitialPermissionsNotGranted,
     UserMediaStatus.InitialPermissionsVideoInputDenied,
 ].includes(status);
+const PermissionPromptStatusSet = new Set([
+    UserMediaStatus.InitialPermissionsNotGranted,
+    UserMediaStatus.InitialPermissionsAudioInputGranted,
+    UserMediaStatus.InitialPermissionsVideoInputGranted,
+]);
+export const isRequestPermissionNeeded = status => PermissionPromptStatusSet.has(status);
 export const isInitialPermissionsGranted = status => [
     UserMediaStatus.InitialPermissionsGranted,
     UserMediaStatus.InitialPermissionsGrantedAudioInputDenied,
+    UserMediaStatus.InitialPermissionsAudioInputGranted,
     UserMediaStatus.InitialPermissionsGrantedVideoInputDenied,
+    UserMediaStatus.InitialPermissionsVideoInputGranted,
 ].includes(status);
 export const isAudioDeviceInUse = status => status === UserMediaStatus.AudioDeviceInUse;
 export const isDeviceInUse = status => [

package/dist/tsconfig.build.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/audioMixingProcessor.ts","../src/audioProcessor.ts","../src/baseLogger.ts","../src/constants.ts","../src/displayMedia.ts","../src/index.ts","../src/logger.ts","../src/media.ts","../src/previewController.ts","../src/signals.ts","../src/status.ts","../src/typeGuard.ts","../src/types.ts","../src/userMedia.ts","../src/utils.ts","../src/videoProcessor.ts","../../../@types/globals.d.ts"],"version":"5.7.3"}

package/dist/typeGuard.d.ts

@@ -1,5 +1,5 @@
 import type { AnalyzerNodeInit } from '@pexip/media-processor';
-import type { Media, AudioContentHint, VideoContentHint } from './types';
+import type { AudioContentHint, Media, VideoContentHint, VideoStreamTrackProcessorAPIs } 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,3 +7,4 @@ 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,3 +38,6 @@ export const isVideoContentHint = (value) => {
     }
     return false;
 };
+export const isVideoStreamTrackProcessorAPIs = (value) => {
+    return (typeof value === 'string' && (value === 'stream' || value === 'canvas'));
+};

package/dist/types.d.ts

@@ -128,7 +128,7 @@ export interface Media extends MediaAttributes {
     getVideoTracks(): MediaTrack[];
     addTrack(track: MediaTrack): void;
     removeTrack(track: MediaTrack): void;
-    clone(): Media;
+    clone(signals?: MediaSignals): Media;
 }
 export interface MediaInit {
     constraints: MediaDeviceRequest;
@@ -181,7 +181,7 @@ export interface MediaTrack {
     getConstraints(): InputDeviceConstraint;
     applyConstraints(constraints: InputDeviceConstraint): Promise<void>;
     release(): Promise<void>;
-    clone(): MediaTrack;
+    clone(signals?: MediaSignals): MediaTrack;
     toJSON(): unknown;
 }
 export interface MediaTrackInit extends Partial<MediaTrack> {
@@ -205,7 +205,7 @@ export type GetUserMediaProcess = (request: {
 }) => Promise<Media>;
 /**
  * Use which processor API to process the stream track
- * `stream` - Use MediaStreamTrackProcessor, when available
+ * `stream` - Use `MediaStreamTrackProcessor`, when available
  * `canvas` - Use Canvas
  */
 export type VideoStreamTrackProcessorAPIs = 'stream' | 'canvas';

package/dist/userMedia.d.ts

@@ -11,7 +11,13 @@ 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.PermissionsOnlyAudioinput | UserMediaStatus.PermissionsOnlyAudioinputNoVideoDevices | UserMediaStatus.PermissionsOnlyAudioinputFallback | UserMediaStatus.PermissionsOnlyAudioinputFallbackNoVideoDevices | UserMediaStatus.PermissionsOnlyVideoinput | UserMediaStatus.PermissionsOnlyVideoinputNoAudioDevices | UserMediaStatus.PermissionsOnlyVideoinputFallback | UserMediaStatus.PermissionsOnlyVideoinputFallbackNoAudioDevices;
+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 hasLiveTrack: (kind: "audio" | "video", tracks: MediaStreamTrack[]) => boolean;
+/**
+ * Merge the previous status with the next status and assuming requesting both
+ * video and audio inputs.
+ */
+export declare const mergeStatus: (prevStatus: UserMediaStatus, nextStatus: UserMediaStatus, prevTracks?: MediaStreamTrack[], nextTracks?: MediaStreamTrack[]) => UserMediaStatus;
 /**
  * Try to come up with an error level according to provided UserMediaStatus and
  * MediaDeviceRequest
@@ -26,6 +32,7 @@ export declare const mergeNoDeviceStatus: (constraints: MediaDeviceRequest, anyD
     audio: boolean;
     video: boolean;
 }, status: UserMediaStatus) => UserMediaStatus;
+export declare const deriveUserMediaStatus: (devices: IndexedDevices, constraints: MediaDeviceRequest, prevStatus: UserMediaStatus) => UserMediaStatus;
 export declare const requestUserMediaWithRetry: (getCurrentDevices: GetCurrentDevices, createRequestUserMedia?: (getCurrentDevices: GetCurrentDevices, getMedia?: ({ audio, video, }: MediaDeviceRequest) => Promise<MediaStream>) => GetUserMedia, gUM?: ({ audio, video, }: MediaDeviceRequest) => Promise<MediaStream>) => GetUserMedia;
 interface Options {
     getUserMedia: GetUserMedia;

package/dist/userMedia.js

@@ -72,26 +72,317 @@ export const toSameDeviceStatus = ({ audio, video, }) => {
     return UserMediaStatus.PermissionsGrantedFallback;
 };
 export const toOnlyDeviceStatus = (kind, matched, devices) => {
-    const hasRelatedDevices = devices.size(kind) > 0;
+    const hasAnotherTypeOfAuthorizedDevice = devices.anyAuthorizedDevice(kind === 'audioinput' ? 'videoinput' : 'audioinput');
+    const hasAnotherTypeOfDevice = devices.size(kind === 'audioinput' ? 'videoinput' : 'audioinput') > 0;
     if (matched) {
-        if (hasRelatedDevices) {
+        if (hasAnotherTypeOfDevice) {
+            if (hasAnotherTypeOfAuthorizedDevice) {
+                return kind === 'audioinput'
+                    ? UserMediaStatus.PermissionsOnlyAudioinput
+                    : UserMediaStatus.PermissionsOnlyVideoinput;
+            }
             return kind === 'audioinput'
-                ? UserMediaStatus.PermissionsOnlyAudioinput
-                : UserMediaStatus.PermissionsOnlyVideoinput;
+                ? UserMediaStatus.PermissionsRejectedVideoInput
+                : UserMediaStatus.PermissionsRejectedAudioInput;
         }
         return kind === 'audioinput'
             ? UserMediaStatus.PermissionsOnlyAudioinputNoVideoDevices
             : UserMediaStatus.PermissionsOnlyVideoinputNoAudioDevices;
     }
-    if (hasRelatedDevices) {
+    if (hasAnotherTypeOfDevice) {
+        if (hasAnotherTypeOfAuthorizedDevice) {
+            return kind === 'audioinput'
+                ? UserMediaStatus.PermissionsOnlyAudioinputFallback
+                : UserMediaStatus.PermissionsOnlyVideoinputFallback;
+        }
         return kind === 'audioinput'
-            ? UserMediaStatus.PermissionsOnlyAudioinputFallback
-            : UserMediaStatus.PermissionsOnlyVideoinputFallback;
+            ? UserMediaStatus.PermissionsRejectedVideoInput
+            : UserMediaStatus.PermissionsRejectedAudioInput;
     }
     return kind === 'audioinput'
         ? UserMediaStatus.PermissionsOnlyAudioinputFallbackNoVideoDevices
         : UserMediaStatus.PermissionsOnlyVideoinputFallbackNoAudioDevices;
 };
+export const hasLiveTrack = (kind, tracks) => tracks.some(track => track.kind === kind && track.readyState === 'live');
+/**
+ * Merge the previous status with the next status and assuming requesting both
+ * video and audio inputs.
+ */
+export const mergeStatus = (prevStatus, nextStatus, prevTracks = [], nextTracks = []) => {
+    const hasPrevLiveAudio = hasLiveTrack('audio', prevTracks);
+    const hasPrevLiveVideo = hasLiveTrack('video', prevTracks);
+    const hasNextLiveAudio = hasLiveTrack('audio', nextTracks);
+    const hasNextLiveVideo = hasLiveTrack('video', nextTracks);
+    // Replace Audio Track
+    if (hasNextLiveAudio) {
+        assert(hasPrevLiveAudio === false, 'Only 1 live audio');
+        // Replace Audio and Video tracks
+        if (hasNextLiveVideo) {
+            assert(hasPrevLiveVideo === false, 'Only 1 live video');
+            // No need to consider the previous status
+            switch (nextStatus) {
+                case UserMediaStatus.PermissionsOnlyVideoinput:
+                case UserMediaStatus.PermissionsOnlyAudioinput:
+                    return UserMediaStatus.PermissionsGranted;
+                case UserMediaStatus.PermissionsOnlyAudioinputFallback:
+                    return UserMediaStatus.PermissionsGrantedFallbackAudioinput;
+                case UserMediaStatus.PermissionsOnlyVideoinputFallback:
+                    return UserMediaStatus.PermissionsGrantedFallbackVideoinput;
+                default:
+                    return nextStatus;
+            }
+        }
+        if (hasPrevLiveVideo) {
+            // Merge previous video status with next audio status
+            switch (prevStatus) {
+                case UserMediaStatus.PermissionsGranted:
+                case UserMediaStatus.PermissionsGrantedFallbackAudioinput:
+                case UserMediaStatus.PermissionsOnlyVideoinputNoAudioDevices:
+                case UserMediaStatus.PermissionsOnlyVideoinput: {
+                    switch (nextStatus) {
+                        case UserMediaStatus.PermissionsOnlyAudioinput:
+                            return UserMediaStatus.PermissionsGranted;
+                        case UserMediaStatus.PermissionsGrantedFallback:
+                        case UserMediaStatus.PermissionsOnlyAudioinputFallback:
+                            return UserMediaStatus.PermissionsGrantedFallbackAudioinput;
+                        default:
+                            return nextStatus;
+                    }
+                }
+                case UserMediaStatus.PermissionsGrantedFallbackVideoinput:
+                case UserMediaStatus.PermissionsGrantedFallback:
+                case UserMediaStatus.PermissionsOnlyVideoinputFallbackNoAudioDevices:
+                case UserMediaStatus.PermissionsOnlyVideoinputFallback: {
+                    switch (nextStatus) {
+                        case UserMediaStatus.PermissionsGranted:
+                        case UserMediaStatus.PermissionsOnlyAudioinput:
+                            return UserMediaStatus.PermissionsGrantedFallbackVideoinput;
+                        case UserMediaStatus.PermissionsGrantedFallbackAudioinput:
+                        case UserMediaStatus.PermissionsOnlyAudioinputFallback:
+                            return UserMediaStatus.PermissionsGrantedFallback;
+                        default:
+                            return nextStatus;
+                    }
+                }
+                default:
+                    return nextStatus;
+            }
+        }
+        // No previous Live Video
+        switch (nextStatus) {
+            case UserMediaStatus.PermissionsRejected:
+            case UserMediaStatus.PermissionsRejectedVideoInput: {
+                switch (prevStatus) {
+                    case UserMediaStatus.PermissionsGrantedFallback:
+                    case UserMediaStatus.PermissionsGrantedFallbackAudioinput:
+                    case UserMediaStatus.PermissionsOnlyAudioinputFallback:
+                    case UserMediaStatus.PermissionsOnlyAudioinputFallbackNoVideoDevices:
+                        return UserMediaStatus.PermissionsOnlyAudioinputFallback;
+                    default:
+                        return UserMediaStatus.PermissionsOnlyAudioinput;
+                }
+            }
+            case UserMediaStatus.NoDevicesFound:
+            case UserMediaStatus.AudioVideoDevicesNotFound:
+            case UserMediaStatus.VideoDeviceNotFound:
+            case UserMediaStatus.NoVideoDevicesFound:
+                switch (prevStatus) {
+                    case UserMediaStatus.PermissionsGrantedFallback:
+                    case UserMediaStatus.PermissionsGrantedFallbackAudioinput:
+                    case UserMediaStatus.PermissionsOnlyAudioinputFallback:
+                    case UserMediaStatus.PermissionsOnlyAudioinputFallbackNoVideoDevices:
+                        return UserMediaStatus.PermissionsOnlyAudioinputFallbackNoVideoDevices;
+                    default:
+                        return UserMediaStatus.PermissionsOnlyAudioinputNoVideoDevices;
+                }
+            case UserMediaStatus.DevicesInUse:
+            case UserMediaStatus.VideoDeviceInUse:
+                return UserMediaStatus.VideoDeviceInUse;
+            case UserMediaStatus.Overconstrained:
+            case UserMediaStatus.VideoOverconstrained:
+                return UserMediaStatus.VideoOverconstrained;
+            case UserMediaStatus.NotSupportedError:
+            case UserMediaStatus.NotSupportedErrorOnlyVideoInput:
+                return UserMediaStatus.NotSupportedErrorOnlyVideoInput;
+            case UserMediaStatus.InvalidConstraints:
+            case UserMediaStatus.InvalidVideoConstraints:
+                return UserMediaStatus.InvalidVideoConstraints;
+            case UserMediaStatus.UnknownError:
+            case UserMediaStatus.UnknownErrorOnlyVideoinput:
+                return UserMediaStatus.UnknownErrorOnlyVideoinput;
+            default:
+                return nextStatus;
+        }
+    }
+    // Replace Video Track Only
+    if (hasNextLiveVideo) {
+        assert(hasPrevLiveVideo === false, 'Only 1 live video');
+        if (hasPrevLiveAudio) {
+            switch (prevStatus) {
+                case UserMediaStatus.PermissionsGranted:
+                case UserMediaStatus.PermissionsGrantedFallbackVideoinput:
+                case UserMediaStatus.PermissionsOnlyAudioinputNoVideoDevices:
+                case UserMediaStatus.PermissionsOnlyAudioinput: {
+                    switch (nextStatus) {
+                        case UserMediaStatus.PermissionsOnlyVideoinput:
+                            return UserMediaStatus.PermissionsGranted;
+                        case UserMediaStatus.PermissionsGrantedFallback:
+                        case UserMediaStatus.PermissionsOnlyVideoinputFallback:
+                            return UserMediaStatus.PermissionsGrantedFallbackVideoinput;
+                        default:
+                            return nextStatus;
+                    }
+                }
+                case UserMediaStatus.PermissionsGrantedFallbackAudioinput:
+                case UserMediaStatus.PermissionsGrantedFallback:
+                case UserMediaStatus.PermissionsOnlyAudioinputFallbackNoVideoDevices:
+                case UserMediaStatus.PermissionsOnlyAudioinputFallback: {
+                    switch (nextStatus) {
+                        case UserMediaStatus.PermissionsGranted:
+                        case UserMediaStatus.PermissionsOnlyVideoinput:
+                            return UserMediaStatus.PermissionsGrantedFallbackAudioinput;
+                        case UserMediaStatus.PermissionsGrantedFallbackVideoinput:
+                        case UserMediaStatus.PermissionsOnlyVideoinputFallback:
+                            return UserMediaStatus.PermissionsGrantedFallback;
+                        default:
+                            return nextStatus;
+                    }
+                }
+                default:
+                    return nextStatus;
+            }
+        }
+    }
+    // Failed to get a new track
+    if (hasPrevLiveAudio) {
+        switch (nextStatus) {
+            case UserMediaStatus.PermissionsRejected:
+            case UserMediaStatus.PermissionsRejectedVideoInput: {
+                switch (prevStatus) {
+                    case UserMediaStatus.PermissionsGrantedFallback:
+                    case UserMediaStatus.PermissionsGrantedFallbackAudioinput:
+                    case UserMediaStatus.PermissionsOnlyAudioinputFallback:
+                    case UserMediaStatus.PermissionsOnlyAudioinputFallbackNoVideoDevices:
+                        return UserMediaStatus.PermissionsOnlyAudioinputFallback;
+                    default:
+                        return UserMediaStatus.PermissionsOnlyAudioinput;
+                }
+            }
+            case UserMediaStatus.NoDevicesFound:
+            case UserMediaStatus.AudioVideoDevicesNotFound:
+            case UserMediaStatus.VideoDeviceNotFound:
+            case UserMediaStatus.NoVideoDevicesFound:
+                switch (prevStatus) {
+                    case UserMediaStatus.PermissionsGrantedFallback:
+                    case UserMediaStatus.PermissionsGrantedFallbackAudioinput:
+                    case UserMediaStatus.PermissionsOnlyAudioinputFallback:
+                    case UserMediaStatus.PermissionsOnlyAudioinputFallbackNoVideoDevices:
+                        return UserMediaStatus.PermissionsOnlyAudioinputFallbackNoVideoDevices;
+                    default:
+                        return UserMediaStatus.PermissionsOnlyAudioinputNoVideoDevices;
+                }
+            case UserMediaStatus.DevicesInUse:
+            case UserMediaStatus.VideoDeviceInUse:
+                return UserMediaStatus.VideoDeviceInUse;
+            case UserMediaStatus.Overconstrained:
+            case UserMediaStatus.VideoOverconstrained:
+                return UserMediaStatus.VideoOverconstrained;
+            case UserMediaStatus.NotSupportedError:
+            case UserMediaStatus.NotSupportedErrorOnlyVideoInput:
+                return UserMediaStatus.NotSupportedErrorOnlyVideoInput;
+            case UserMediaStatus.InvalidConstraints:
+            case UserMediaStatus.InvalidVideoConstraints:
+                return UserMediaStatus.InvalidVideoConstraints;
+            case UserMediaStatus.UnknownError:
+            case UserMediaStatus.UnknownErrorOnlyVideoinput:
+                return UserMediaStatus.UnknownErrorOnlyVideoinput;
+            default:
+                return prevStatus;
+        }
+    }
+    if (hasPrevLiveVideo) {
+        switch (nextStatus) {
+            case UserMediaStatus.PermissionsRejected:
+            case UserMediaStatus.PermissionsRejectedAudioInput:
+                switch (prevStatus) {
+                    case UserMediaStatus.PermissionsGrantedFallback:
+                    case UserMediaStatus.PermissionsGrantedFallbackVideoinput:
+                    case UserMediaStatus.PermissionsOnlyVideoinputFallback:
+                    case UserMediaStatus.PermissionsOnlyVideoinputFallbackNoAudioDevices:
+                        return UserMediaStatus.PermissionsOnlyVideoinputFallback;
+                    default:
+                        return UserMediaStatus.PermissionsOnlyVideoinput;
+                }
+            case UserMediaStatus.NoDevicesFound:
+            case UserMediaStatus.AudioVideoDevicesNotFound:
+            case UserMediaStatus.AudioDeviceNotFound:
+            case UserMediaStatus.NoAudioDevicesFound: {
+                switch (prevStatus) {
+                    case UserMediaStatus.PermissionsGrantedFallback:
+                    case UserMediaStatus.PermissionsGrantedFallbackVideoinput:
+                    case UserMediaStatus.PermissionsOnlyVideoinputFallback:
+                    case UserMediaStatus.PermissionsOnlyVideoinputFallbackNoAudioDevices:
+                        return UserMediaStatus.PermissionsOnlyVideoinputFallbackNoAudioDevices;
+                    default:
+                        return UserMediaStatus.PermissionsOnlyVideoinputNoAudioDevices;
+                }
+            }
+            case UserMediaStatus.DevicesInUse:
+            case UserMediaStatus.AudioDeviceInUse:
+                return UserMediaStatus.AudioDeviceInUse;
+            case UserMediaStatus.Overconstrained:
+            case UserMediaStatus.AudioOverconstrained:
+                return UserMediaStatus.AudioOverconstrained;
+            case UserMediaStatus.NotSupportedError:
+            case UserMediaStatus.NotSupportedErrorOnlyAudioInput:
+                return UserMediaStatus.NotSupportedErrorOnlyAudioInput;
+            case UserMediaStatus.InvalidConstraints:
+            case UserMediaStatus.InvalidAudioConstraints:
+                return UserMediaStatus.InvalidAudioConstraints;
+            case UserMediaStatus.UnknownError:
+            case UserMediaStatus.UnknownErrorOnlyAudioinput:
+                return UserMediaStatus.UnknownErrorOnlyAudioinput;
+            default:
+                return prevStatus;
+        }
+    }
+    switch (nextStatus) {
+        case UserMediaStatus.PermissionsRejected:
+        case UserMediaStatus.PermissionsRejectedAudioInput:
+        case UserMediaStatus.PermissionsRejectedVideoInput:
+            return UserMediaStatus.PermissionsRejected;
+        case UserMediaStatus.NoDevicesFound:
+        case UserMediaStatus.AudioVideoDevicesNotFound:
+        case UserMediaStatus.AudioDeviceNotFound:
+        case UserMediaStatus.VideoDeviceNotFound:
+        case UserMediaStatus.NoVideoDevicesFound:
+        case UserMediaStatus.NoAudioDevicesFound: {
+            return UserMediaStatus.NoDevicesFound;
+        }
+        case UserMediaStatus.DevicesInUse:
+        case UserMediaStatus.AudioDeviceInUse:
+        case UserMediaStatus.VideoDeviceInUse:
+            return UserMediaStatus.DevicesInUse;
+        case UserMediaStatus.Overconstrained:
+        case UserMediaStatus.AudioOverconstrained:
+        case UserMediaStatus.VideoOverconstrained:
+            return UserMediaStatus.Overconstrained;
+        case UserMediaStatus.InvalidConstraints:
+        case UserMediaStatus.InvalidVideoConstraints:
+        case UserMediaStatus.InvalidAudioConstraints:
+            return UserMediaStatus.InvalidConstraints;
+        case UserMediaStatus.NotSupportedError:
+        case UserMediaStatus.NotSupportedErrorOnlyAudioInput:
+        case UserMediaStatus.NotSupportedErrorOnlyVideoInput:
+            return UserMediaStatus.NotSupportedError;
+        case UserMediaStatus.UnknownError:
+        case UserMediaStatus.UnknownErrorOnlyAudioinput:
+        case UserMediaStatus.UnknownErrorOnlyVideoinput:
+            return UserMediaStatus.UnknownError;
+        default:
+            return nextStatus;
+    }
+};
 /**
  * Try to come up with an error level according to provided UserMediaStatus and
  * MediaDeviceRequest
@@ -116,18 +407,26 @@ export const deriveErrorLevel = (error, status, constraints) => {
         : 'warn';
 };
 export const requestUserMedia = (getCurrentDevices, getMedia = getUserMedia) => async (constraints) => {
-    const deriveDeviceStatus = makeDeriveDeviceStatus(constraints);
     try {
         const stream = await getMedia(constraints);
-        const grantedDevices = await getCurrentDevices();
-        const { audio, video } = isStreamingRequestedDevices(constraints, stream, grantedDevices);
-        const onlyAudioStatus = toOnlyDeviceStatus('audioinput', audio, grantedDevices);
-        const onlyVideoStatus = toOnlyDeviceStatus('videoinput', video, grantedDevices);
+        const devices = await getCurrentDevices();
+        const deriveDeviceStatus = makeDeriveDeviceStatus({
+            audio: devices.anyAuthorizedDevice('audioinput')
+                ? constraints.audio
+                : false,
+            video: devices.anyAuthorizedDevice('videoinput')
+                ? 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 }));
         return [stream, status];
     }
     catch (error) {
         if (error instanceof Error) {
+            const deriveDeviceStatus = makeDeriveDeviceStatus(constraints);
             const status = toErrorDeviceStatus(error, deriveDeviceStatus);
             return [undefined, status];
         }
@@ -150,17 +449,18 @@ export const mergeNoDeviceStatus = (constraints, anyDevices, status) => {
     }
     return status;
 };
+export const deriveUserMediaStatus = (devices, constraints, prevStatus) => {
+    const anyAudioDevices = devices.size('audioinput') > 0;
+    const anyVideoDevices = devices.size('videoinput') > 0;
+    return mergeNoDeviceStatus(constraints, { audio: anyAudioDevices, video: anyVideoDevices }, prevStatus);
+};
 export const requestUserMediaWithRetry = (getCurrentDevices, createRequestUserMedia = requestUserMedia, gUM = getUserMedia) => {
     const request = createRequestUserMedia(getCurrentDevices, gUM);
     return async (constraints) => {
         const [stream, status] = await request(constraints);
         const devices = await getCurrentDevices();
-        const anyAudioDevices = devices.size('audioinput') > 0;
-        const anyVideoDevices = devices.size('videoinput') > 0;
-        return [
-            stream,
-            mergeNoDeviceStatus(constraints, { audio: anyAudioDevices, video: anyVideoDevices }, status),
-        ];
+        const finalStatus = deriveUserMediaStatus(devices, constraints, status);
+        return [stream, finalStatus];
     };
 };
 /**
@@ -216,8 +516,32 @@ export const createGetUserMediaProcess = ({ getUserMedia, getCurrentDevices, sig
                 }));
         }
         const [stream, status] = await getUserMedia(constraints);
-        logger.debug({ scope, stream, status }, 'post getUserMedia');
+        let finalStatus = status;
+        if (currentMedia &&
+            constraints.audio !== false &&
+            constraints.video !== false) {
+            finalStatus = mergeStatus(currentMedia.status, status, 
+            // When the constraint is undefined, it means the track will be kept as what it is.
+            // i.e. It belongs to the next track for this mergeStatus logic.
+            [
+                ...(constraints.audio === undefined
+                    ? []
+                    : currentMedia.stream.getAudioTracks()),
+                ...(constraints.video === undefined
+                    ? []
+                    : currentMedia.stream.getVideoTracks()),
+            ], [
+                ...(stream?.getTracks() ?? []),
+                ...(constraints.audio === undefined
+                    ? currentMedia.stream.getAudioTracks()
+                    : []),
+                ...(constraints.video === undefined
+                    ? currentMedia.stream.getVideoTracks()
+                    : []),
+            ]);
+        }
         const devices = await getCurrentDevices();
+        logger.debug({ scope, stream, devices, status: finalStatus }, 'post getUserMedia');
         const findInput = findMediaInputFromMediaStreamTrack(devices);
         let audioMediaTrack;
         let videoMediaTrack;
@@ -225,6 +549,7 @@ export const createGetUserMediaProcess = ({ getUserMedia, getCurrentDevices, sig
         if (constraints.audio !== undefined) {
             const audioTrack = stream?.getAudioTracks().at(0);
             const audioInput = findInput(audioTrack);
+            assert(Boolean(audioTrack) === Boolean(audioInput), 'audioTrack <=> audioInput');
             const { contentHint: [[contentHint] = []], } = extractContentHint(constraints.audio);
             if (audioTrack) {
                 audioTrack.contentHint = contentHint ?? '';
@@ -243,6 +568,7 @@ export const createGetUserMediaProcess = ({ getUserMedia, getCurrentDevices, sig
         if (constraints.video !== undefined) {
             const videoTrack = stream?.getVideoTracks().at(0);
             const videoInput = findInput(videoTrack);
+            assert(Boolean(videoTrack) === Boolean(videoInput), 'videoTrack <=> videoInput');
             const { contentHint: [[contentHint] = []], } = extractContentHint(constraints.video);
             if (videoTrack) {
                 videoTrack.contentHint = contentHint ?? '';
@@ -258,8 +584,19 @@ export const createGetUserMediaProcess = ({ getUserMedia, getCurrentDevices, sig
             });
             currentMedia?.addTrack(videoMediaTrack);
         }
+        logger.info({
+            permission,
+            devices,
+            stream,
+            status: finalStatus,
+            originalConstraints,
+            currentMedia,
+            audioMediaTrack,
+            videoMediaTrack,
+            constraints,
+        }, 'GetUserMedia');
         if (currentMedia) {
-            currentMedia.status = status;
+            currentMedia.status = finalStatus;
             currentMedia.setOriginalConstraints(originalConstraints);
             return currentMedia;
         }

package/dist/utils.d.ts

@@ -1,5 +1,6 @@
-import type { IndexedDevices, InputDeviceConstraint, MediaDeviceInfoLike, MediaDeviceRequest } from '@pexip/media-control';
-import type { ExtendedMediaTrackSettings, ExtendedMediaTrackSettingsKey, Media, MediaInit, MediaTrack, MediaTrackInit, TrackProcessor, UserMediaStatus } from './types';
+import type { IndexedDevices, InputDeviceConstraint, MediaDeviceInfoLike, MediaDeviceRequest, InputConstraintSet } from '@pexip/media-control';
+import { type RenderEffects } from '@pexip/media-processor';
+import type { AudioContentHint, ExtendedMediaTrackSettings, ExtendedMediaTrackSettingsKey, Media, MediaInit, MediaTrack, MediaTrackInit, TrackProcessor, UserMediaStatus, VideoContentHint } from './types';
 export declare const makeDeriveDeviceStatus: (constraints: MediaDeviceRequest) => (audio: UserMediaStatus, video: UserMediaStatus, both: UserMediaStatus) => UserMediaStatus;
 export declare const createMediaTrack: (trackInit: MediaTrackInit) => MediaTrack;
 export declare const createTrackProcessingPipeline: (processors: TrackProcessor[]) => (track: MediaTrack) => Promise<MediaTrack>;
@@ -8,12 +9,12 @@ export declare const createTrackProcessingPipeline: (processors: TrackProcessor[
  * otherwise `undefined`
  */
 export declare const interpretInput: (input: boolean | MediaDeviceInfoLike | undefined, getCurrentInput: () => MediaDeviceInfoLike | undefined) => MediaDeviceInfoLike | undefined;
-export declare const findExpectedInput: (devices: IndexedDevices, constraints: InputDeviceConstraint | undefined, input: MediaDeviceInfoLike | undefined, kind: 'audioinput' | 'videoinput') => MediaDeviceInfoLike | undefined;
+export declare const findExpectedInput: (devices: IndexedDevices, constraints: InputDeviceConstraint | undefined, input: MediaDeviceInfoLike | undefined, kind: "audioinput" | "videoinput") => MediaDeviceInfoLike | undefined;
 /**
  * A utility function to check if the provided track is muted. There are
  * 2 factors to be considered: `MediaStreamTrack['muted']` and `MediaStreamTrack['enabled']`.
  *
- * ```
+ * ```md
  * | muted \ enabled | true  | false |
  * |-----------------| ----- | ----- |
  * |     true        | true  | true  |
@@ -27,7 +28,7 @@ export declare const findExpectedInput: (devices: IndexedDevices, constraints: I
  * there is no track to check
  */
 export declare const isTrackMuted: (track: MediaStreamTrack | undefined) => boolean | undefined;
-export declare const buildMedia: (mediaInit: MediaInit, onDevicesChanged?: import("@pexip/signal").Signal<IndexedDevices>) => Media;
+export declare const buildMedia: (mediaInit: MediaInit, onDevicesChanged?: import("@pexip/signal").Signal<IndexedDevices, IndexedDevices>) => Media;
 /**
  * Shallow copy the provided object and override with provided overriding
  *
@@ -38,8 +39,6 @@ export declare const buildMedia: (mediaInit: MediaInit, onDevicesChanged?: impor
  */
 export declare const shallowCopy: <T>(original: T, overriding: Partial<T>) => T;
 export declare const getDevicesChanges: (prev: MediaDeviceInfoLike[], next: MediaDeviceInfoLike[]) => {
-    unauthorized: MediaDeviceInfoLike[];
-    authorized: MediaDeviceInfoLike[];
     found: MediaDeviceInfoLike[];
     lost: MediaDeviceInfoLike[];
     devices: MediaDeviceInfoLike[];
@@ -47,7 +46,10 @@ export declare const getDevicesChanges: (prev: MediaDeviceInfoLike[], next: Medi
 export declare const AUDIO_SETTINGS_KEYS: ExtendedMediaTrackSettingsKey[];
 export declare const VIDEO_SETTINGS_KEYS: ExtendedMediaTrackSettingsKey[];
 export declare const MIXING_SETTINGS_KEYS: ExtendedMediaTrackSettingsKey[];
+export declare const PAN_TILT_ZOOM_SETTINGS_KEYS: ExtendedMediaTrackSettingsKey[];
 export declare const hasSettingsChanged: (keysToLookFor: ExtendedMediaTrackSettingsKey[]) => (settingsA: ExtendedMediaTrackSettings | undefined, settingsB: ExtendedMediaTrackSettings | undefined) => boolean;
+export declare const isApplyingRenderEffect: (effect: RenderEffects) => boolean;
+export declare const getSettingsFromKeys: (keys: ExtendedMediaTrackSettingsKey[], settings: InputConstraintSet | undefined | false) => false | ExtendedMediaTrackSettings | undefined;
 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;
 /**
@@ -67,7 +69,7 @@ export declare const getBlurKernelSize: (percentage: number, height: number, max
  * @param hint - Content hint
  * @param track - The track to be applied
  */
-export declare const applyContentHint: <T extends "" | "speech" | "speech-recognition" | "music" | "motion" | "detail" | "text">(hint?: T | undefined) => (track: MediaStreamTrack) => void;
+export declare const applyContentHint: <T extends AudioContentHint | VideoContentHint>(hint?: T) => (track: MediaStreamTrack) => void;
 /**
  * Check if the browser supports PTZ feature
  * @returns true if the browser supports PTZ feature, otherwise false