livekit-client 1.8.0 → 1.9.1

package/src/room/participant/Participant.ts

@@ -2,10 +2,10 @@ import { EventEmitter } from 'events';
 import type TypedEmitter from 'typed-emitter';
 import log from '../../logger';
 import {
-  ConnectionQuality as ProtoQuality,
   DataPacket_Kind,
   ParticipantInfo,
   ParticipantPermission,
+  ConnectionQuality as ProtoQuality,
 } from '../../proto/livekit_models';
 import { ParticipantEvent, TrackEvent } from '../events';
 import type LocalTrackPublication from '../track/LocalTrackPublication';
@@ -144,10 +144,23 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
   }
 
   /** @internal */
-  updateInfo(info: ParticipantInfo) {
+  updateInfo(info: ParticipantInfo): boolean {
+    // it's possible the update could be applied out of order due to await
+    // during reconnect sequences. when that happens, it's possible for server
+    // to have sent more recent version of participant info while JS is waiting
+    // to process the existing payload.
+    // when the participant sid remains the same, and we already have a later version
+    // of the payload, they can be safely skipped
+    if (
+      this.participantInfo &&
+      this.participantInfo.sid === info.sid &&
+      this.participantInfo.version > info.version
+    ) {
+      return false;
+    }
     this.identity = info.identity;
     this.sid = info.sid;
-    this.name = info.name;
+    this.setName(info.name);
     this.setMetadata(info.metadata);
     if (info.permission) {
       this.setPermissions(info.permission);
@@ -155,6 +168,7 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
     // set this last so setMetadata can detect changes
     this.participantInfo = info;
     log.trace('update participant info', { info });
+    return true;
   }
 
   /** @internal */
@@ -168,6 +182,15 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
     }
   }
 
+  protected setName(name: string) {
+    const changed = this.name !== name;
+    this.name = name;
+
+    if (changed) {
+      this.emit(ParticipantEvent.ParticipantNameChanged, name);
+    }
+  }
+
   /** @internal */
   setPermissions(permissions: ParticipantPermission): boolean {
     const prevPermissions = this.permissions;
@@ -250,6 +273,7 @@ export type ParticipantEventCallbacks = {
   localTrackPublished: (publication: LocalTrackPublication) => void;
   localTrackUnpublished: (publication: LocalTrackPublication) => void;
   participantMetadataChanged: (prevMetadata: string | undefined, participant?: any) => void;
+  participantNameChanged: (name: string) => void;
   dataReceived: (payload: Uint8Array, kind: DataPacket_Kind) => void;
   isSpeakingChanged: (speaking: boolean) => void;
   connectionQualityChanged: (connectionQuality: ConnectionQuality) => void;

package/src/room/participant/RemoteParticipant.ts

@@ -3,13 +3,13 @@ import log from '../../logger';
 import type { ParticipantInfo } from '../../proto/livekit_models';
 import type { UpdateSubscription, UpdateTrackSettings } from '../../proto/livekit_rtc';
 import { ParticipantEvent, TrackEvent } from '../events';
-import type { AudioOutputOptions } from '../track/options';
 import RemoteAudioTrack from '../track/RemoteAudioTrack';
 import type RemoteTrack from '../track/RemoteTrack';
 import RemoteTrackPublication from '../track/RemoteTrackPublication';
 import RemoteVideoTrack from '../track/RemoteVideoTrack';
 import { Track } from '../track/Track';
 import type { TrackPublication } from '../track/TrackPublication';
+import type { AudioOutputOptions } from '../track/options';
 import type { AdaptiveStreamSettings } from '../track/types';
 import Participant, { ParticipantEventCallbacks } from './Participant';
 
@@ -215,8 +215,10 @@ export default class RemoteParticipant extends Participant {
   }
 
   /** @internal */
-  updateInfo(info: ParticipantInfo) {
-    super.updateInfo(info);
+  updateInfo(info: ParticipantInfo): boolean {
+    if (!super.updateInfo(info)) {
+      return false;
+    }
 
     // we are getting a list of all available tracks, reconcile in here
     // and send out events for changes
@@ -277,6 +279,7 @@ export default class RemoteParticipant extends Participant {
     newTracks.forEach((publication) => {
       this.emit(ParticipantEvent.TrackPublished, publication);
     });
+    return true;
   }
 
   /** @internal */

package/src/room/participant/publishUtils.test.ts

@@ -3,8 +3,8 @@ import {
   computeDefaultScreenShareSimulcastPresets,
   computeVideoEncodings,
   determineAppropriateEncoding,
-  presets169,
   presets43,
+  presets169,
   presetsForResolution,
   presetsScreenShare,
   sortPresets,

package/src/room/participant/publishUtils.ts

@@ -2,6 +2,7 @@ import log from '../../logger';
 import { TrackInvalidError } from '../errors';
 import LocalAudioTrack from '../track/LocalAudioTrack';
 import LocalVideoTrack from '../track/LocalVideoTrack';
+import { Track } from '../track/Track';
 import {
   BackupVideoCodec,
   ScreenSharePresets,
@@ -12,7 +13,7 @@ import {
   VideoPresets,
   VideoPresets43,
 } from '../track/options';
-import { Track } from '../track/Track';
+import { isSVCCodec } from '../utils';
 
 /** @internal */
 export function mediaTrackToLocalTrack(
@@ -121,7 +122,7 @@ export function computeVideoEncodings(
     videoEncoding.maxFramerate,
   );
 
-  if (scalabilityMode && videoCodec === 'av1') {
+  if (scalabilityMode && isSVCCodec(videoCodec)) {
     log.debug(`using svc with scalabilityMode ${scalabilityMode}`);
 
     const encodings: RTCRtpEncodingParameters[] = [];
@@ -248,8 +249,13 @@ export function determineAppropriateEncoding(
   if (codec) {
     switch (codec) {
       case 'av1':
+        encoding = { ...encoding };
         encoding.maxBitrate = encoding.maxBitrate * 0.7;
         break;
+      case 'vp9':
+        encoding = { ...encoding };
+        encoding.maxBitrate = encoding.maxBitrate * 0.85;
+        break;
       default:
         break;
     }
@@ -303,13 +309,15 @@ function encodingsFromPresets(
     }
     const size = Math.min(width, height);
     const rid = videoRids[idx];
-    encodings.push({
+    const encoding: RTCRtpEncodingParameters = {
       rid,
       scaleResolutionDownBy: Math.max(1, size / Math.min(preset.width, preset.height)),
       maxBitrate: preset.encoding.maxBitrate,
-      /* @ts-ignore */
-      maxFramerate: preset.encoding.maxFramerate,
-    });
+    };
+    if (preset.encoding.maxFramerate) {
+      encoding.maxFramerate = preset.encoding.maxFramerate;
+    }
+    encodings.push(encoding);
   });
   return encodings;
 }

package/src/room/track/LocalAudioTrack.ts

@@ -3,8 +3,8 @@ import { TrackEvent } from '../events';
 import { AudioSenderStats, computeBitrate, monitorFrequency } from '../stats';
 import { isWeb } from '../utils';
 import LocalTrack from './LocalTrack';
-import type { AudioCaptureOptions } from './options';
 import { Track } from './Track';
+import type { AudioCaptureOptions } from './options';
 import { constraintsForOptions, detectSilence } from './utils';
 
 export default class LocalAudioTrack extends LocalTrack {

package/src/room/track/LocalTrack.ts

@@ -3,14 +3,14 @@ import DeviceManager from '../DeviceManager';
 import { TrackInvalidError } from '../errors';
 import { TrackEvent } from '../events';
 import {
+  Mutex,
   getEmptyAudioStreamTrack,
   getEmptyVideoStreamTrack,
   isMobile,
-  Mutex,
   sleep,
 } from '../utils';
+import { Track, attachToElement, detachTrack } from './Track';
 import type { VideoCodec } from './options';
-import { attachToElement, detachTrack, Track } from './Track';
 
 const defaultDimensionsTimeout = 2 * 1000;
 

package/src/room/track/LocalTrackPublication.ts

@@ -3,9 +3,9 @@ import { TrackEvent } from '../events';
 import type LocalAudioTrack from './LocalAudioTrack';
 import type LocalTrack from './LocalTrack';
 import type LocalVideoTrack from './LocalVideoTrack';
-import type { TrackPublishOptions } from './options';
 import type { Track } from './Track';
 import { TrackPublication } from './TrackPublication';
+import type { TrackPublishOptions } from './options';
 
 export default class LocalTrackPublication extends TrackPublication {
   track?: LocalTrack = undefined;

package/src/room/track/LocalVideoTrack.ts

@@ -2,11 +2,11 @@ import type { SignalClient } from '../../api/SignalClient';
 import log from '../../logger';
 import { VideoLayer, VideoQuality } from '../../proto/livekit_models';
 import type { SubscribedCodec, SubscribedQuality } from '../../proto/livekit_rtc';
-import { computeBitrate, monitorFrequency, VideoSenderStats } from '../stats';
-import { isFireFox, isMobile, isWeb, Mutex } from '../utils';
+import { VideoSenderStats, computeBitrate, monitorFrequency } from '../stats';
+import { Mutex, isFireFox, isMobile, isWeb } from '../utils';
 import LocalTrack from './LocalTrack';
-import type { VideoCaptureOptions, VideoCodec } from './options';
 import { Track } from './Track';
+import type { VideoCaptureOptions, VideoCodec } from './options';
 import { constraintsForOptions } from './utils';
 
 export class SimulcastTrackInfo {

package/src/room/track/RemoteAudioTrack.ts

@@ -2,9 +2,9 @@ import log from '../../logger';
 import { TrackEvent } from '../events';
 import { AudioReceiverStats, computeBitrate } from '../stats';
 import { supportsSetSinkId } from '../utils';
-import type { AudioOutputOptions } from './options';
 import RemoteTrack from './RemoteTrack';
 import { Track } from './Track';
+import type { AudioOutputOptions } from './options';
 
 export default class RemoteAudioTrack extends RemoteTrack {
   private prevStats?: AudioReceiverStats;

package/src/room/track/RemoteVideoTrack.test.ts

@@ -1,6 +1,6 @@
+import MockMediaStreamTrack from '../../test/MockMediaStreamTrack';
 import { TrackEvent } from '../events';
 import RemoteVideoTrack, { ElementInfo } from './RemoteVideoTrack';
-import MockMediaStreamTrack from '../../test/MockMediaStreamTrack';
 import type { Track } from './Track';
 
 jest.useFakeTimers();

package/src/room/track/RemoteVideoTrack.ts

@@ -1,17 +1,17 @@
 import { debounce } from 'ts-debounce';
 import log from '../../logger';
 import { TrackEvent } from '../events';
-import { computeBitrate, VideoReceiverStats } from '../stats';
+import { VideoReceiverStats, computeBitrate } from '../stats';
 import CriticalTimers from '../timers';
 import {
+  ObservableMediaElement,
   getDevicePixelRatio,
   getIntersectionObserver,
   getResizeObserver,
   isWeb,
-  ObservableMediaElement,
 } from '../utils';
 import RemoteTrack from './RemoteTrack';
-import { attachToElement, detachTrack, Track } from './Track';
+import { Track, attachToElement, detachTrack } from './Track';
 import type { AdaptiveStreamSettings } from './types';
 
 const REACTION_DELAY = 100;

package/src/room/track/create.ts

@@ -1,10 +1,11 @@
 import DeviceManager from '../DeviceManager';
+import { audioDefaults, videoDefaults } from '../defaults';
 import { DeviceUnsupportedError, TrackInvalidError } from '../errors';
 import { mediaTrackToLocalTrack } from '../participant/publishUtils';
-import { audioDefaults, videoDefaults } from '../defaults';
 import LocalAudioTrack from './LocalAudioTrack';
 import type LocalTrack from './LocalTrack';
 import LocalVideoTrack from './LocalVideoTrack';
+import { Track } from './Track';
 import {
   AudioCaptureOptions,
   CreateLocalTracksOptions,
@@ -12,7 +13,6 @@ import {
   VideoCaptureOptions,
   VideoPresets,
 } from './options';
-import { Track } from './Track';
 import { constraintsForOptions, mergeDefaultOptions } from './utils';
 
 /**

package/src/room/track/options.ts

@@ -145,6 +145,12 @@ export interface ScreenShareCaptureOptions {
 
   /** specifies whether the browser should include the system audio among the possible audio sources offered to the user */
   systemAudio?: 'include' | 'exclude';
+
+  /**
+   * Experimental option to control whether the audio playing in a tab will continue to be played out of a user's
+   * local speakers when the tab is captured.
+   */
+  suppressLocalAudioPlayback?: boolean;
 }
 
 export interface AudioCaptureOptions {
@@ -241,7 +247,7 @@ export interface AudioPreset {
   maxBitrate: number;
 }
 
-const codecs = ['vp8', 'h264', 'av1'] as const;
+const codecs = ['vp8', 'h264', 'vp9', 'av1'] as const;
 const backupCodecs = ['vp8', 'h264'] as const;
 
 export type VideoCodec = (typeof codecs)[number];
@@ -252,6 +258,13 @@ export function isBackupCodec(codec: string): codec is BackupVideoCodec {
   return !!backupCodecs.find((backup) => backup === codec);
 }
 
+export function isCodecEqual(c1: string | undefined, c2: string | undefined): boolean {
+  return (
+    c1?.toLowerCase().replace(/audio\/|video\//y, '') ===
+    c2?.toLowerCase().replace(/audio\/|video\//y, '')
+  );
+}
+
 /**
  * scalability modes for svc, only supprot l3t3 now.
  */

package/src/room/types.ts

@@ -26,3 +26,14 @@ export type LiveKitReactNativeInfo = {
   platform: 'ios' | 'android' | 'windows' | 'macos' | 'web' | 'native';
   devicePixelRatio: number;
 };
+
+export type SimulationScenario =
+  | 'signal-reconnect'
+  | 'speaker'
+  | 'node-failure'
+  | 'server-leave'
+  | 'migration'
+  | 'resume-reconnect'
+  | 'force-tcp'
+  | 'force-tls'
+  | 'full-reconnect';

package/src/room/utils.ts

@@ -7,6 +7,8 @@ import { getNewAudioContext } from './track/utils';
 import type { LiveKitReactNativeInfo } from './types';
 
 const separator = '|';
+export const ddExtensionURI =
+  'https://aomediacodec.github.io/av1-rtp-spec/#dependency-descriptor-rtp-header-extension';
 
 export function unpackStreamId(packed: string): string[] {
   const parts = packed.split(separator);
@@ -41,7 +43,6 @@ export function supportsDynacast() {
 export function supportsAV1(): boolean {
   const capabilities = RTCRtpReceiver.getCapabilities('video');
   let hasAV1 = false;
-  let hasDDExt = false;
   if (capabilities) {
     for (const codec of capabilities.codecs) {
       if (codec.mimeType === 'video/AV1') {
@@ -49,17 +50,26 @@ export function supportsAV1(): boolean {
         break;
       }
     }
-    for (const ext of capabilities.headerExtensions) {
-      if (
-        ext.uri ===
-        'https://aomediacodec.github.io/av1-rtp-spec/#dependency-descriptor-rtp-header-extension'
-      ) {
-        hasDDExt = true;
+  }
+  return hasAV1;
+}
+
+export function supportsVP9(): boolean {
+  const capabilities = RTCRtpReceiver.getCapabilities('video');
+  let hasVP9 = false;
+  if (capabilities) {
+    for (const codec of capabilities.codecs) {
+      if (codec.mimeType === 'video/VP9') {
+        hasVP9 = true;
         break;
       }
     }
   }
-  return hasAV1 && hasDDExt;
+  return hasVP9;
+}
+
+export function isSVCCodec(codec?: string): boolean {
+  return codec === 'av1' || codec === 'vp9';
 }
 
 export function supportsSetSinkId(elm?: HTMLMediaElement): boolean {