livekit-client 2.5.0 → 2.5.2

package/src/room/timers.ts

@@ -4,13 +4,22 @@
  * that the timer fires on time.
  */
 export default class CriticalTimers {
-  // eslint-disable-next-line @typescript-eslint/no-implied-eval
-  static setTimeout = (...args: Parameters<typeof setTimeout>) => setTimeout(...args);
+  static setTimeout: (...args: Parameters<typeof setTimeout>) => ReturnType<typeof setTimeout> = (
+    ...args: Parameters<typeof setTimeout>
+    // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  ) => setTimeout(...args);
 
-  // eslint-disable-next-line @typescript-eslint/no-implied-eval
-  static setInterval = (...args: Parameters<typeof setInterval>) => setInterval(...args);
+  static setInterval: (...args: Parameters<typeof setInterval>) => ReturnType<typeof setInterval> =
+    // eslint-disable-next-line @typescript-eslint/no-implied-eval
+    (...args: Parameters<typeof setInterval>) => setInterval(...args);
 
-  static clearTimeout = (...args: Parameters<typeof clearTimeout>) => clearTimeout(...args);
+  static clearTimeout: (
+    ...args: Parameters<typeof clearTimeout>
+  ) => ReturnType<typeof clearTimeout> = (...args: Parameters<typeof clearTimeout>) =>
+    clearTimeout(...args);
 
-  static clearInterval = (...args: Parameters<typeof clearInterval>) => clearInterval(...args);
+  static clearInterval: (
+    ...args: Parameters<typeof clearInterval>
+  ) => ReturnType<typeof clearInterval> = (...args: Parameters<typeof clearInterval>) =>
+    clearInterval(...args);
 }

package/src/room/track/LocalTrack.ts

@@ -215,7 +215,7 @@ export default abstract class LocalTrack<
   /**
    * @returns DeviceID of the device that is currently being used for this track
    */
-  async getDeviceId(): Promise<string | undefined> {
+  async getDeviceId(normalize = true): Promise<string | undefined> {
     // screen share doesn't have a usable device id
     if (this.source === Track.Source.ScreenShare) {
       return;
@@ -223,7 +223,9 @@ export default abstract class LocalTrack<
     const { deviceId, groupId } = this._mediaStreamTrack.getSettings();
     const kind = this.kind === Track.Kind.Audio ? 'audioinput' : 'videoinput';
 
-    return DeviceManager.getInstance().normalizeDeviceId(kind, deviceId, groupId);
+    return normalize
+      ? DeviceManager.getInstance().normalizeDeviceId(kind, deviceId, groupId)
+      : deviceId;
   }
 
   async mute() {

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

@@ -47,6 +47,66 @@ describe('videoLayersFromEncodings', () => {
     expect(layers[2].height).toBe(720);
   });
 
+  it('returns qualities starting from lowest for SVC', () => {
+    const layers = videoLayersFromEncodings(
+      1280,
+      720,
+      [
+        {
+          /** @ts-ignore */
+          scalabilityMode: 'L2T2',
+        },
+      ],
+      true,
+    );
+
+    expect(layers).toHaveLength(2);
+    expect(layers[0].quality).toBe(VideoQuality.MEDIUM);
+    expect(layers[0].width).toBe(1280);
+    expect(layers[1].quality).toBe(VideoQuality.LOW);
+    expect(layers[1].width).toBe(640);
+  });
+
+  it('returns qualities starting from lowest for SVC (three layers)', () => {
+    const layers = videoLayersFromEncodings(
+      1280,
+      720,
+      [
+        {
+          /** @ts-ignore */
+          scalabilityMode: 'L3T3',
+        },
+      ],
+      true,
+    );
+
+    expect(layers).toHaveLength(3);
+    expect(layers[0].quality).toBe(VideoQuality.HIGH);
+    expect(layers[0].width).toBe(1280);
+    expect(layers[1].quality).toBe(VideoQuality.MEDIUM);
+    expect(layers[1].width).toBe(640);
+    expect(layers[2].quality).toBe(VideoQuality.LOW);
+    expect(layers[2].width).toBe(320);
+  });
+
+  it('returns qualities starting from lowest for SVC (single layer)', () => {
+    const layers = videoLayersFromEncodings(
+      1280,
+      720,
+      [
+        {
+          /** @ts-ignore */
+          scalabilityMode: 'L1T2',
+        },
+      ],
+      true,
+    );
+
+    expect(layers).toHaveLength(1);
+    expect(layers[0].quality).toBe(VideoQuality.LOW);
+    expect(layers[0].width).toBe(1280);
+  });
+
   it('handles portrait', () => {
     const layers = videoLayersFromEncodings(720, 1280, [
       {

package/src/room/track/LocalVideoTrack.ts

@@ -607,7 +607,7 @@ export function videoLayersFromEncodings(
     for (let i = 0; i < sm.spatial; i += 1) {
       layers.push(
         new VideoLayer({
-          quality: VideoQuality.HIGH - i,
+          quality: Math.min(VideoQuality.HIGH, sm.spatial - 1) - i,
           width: Math.ceil(width / resRatio ** i),
           height: Math.ceil(height / resRatio ** i),
           bitrate: encodings[0].maxBitrate

package/src/room/track/create.ts

@@ -14,13 +14,32 @@ import type {
   VideoCaptureOptions,
 } from './options';
 import { ScreenSharePresets } from './options';
-import type { TrackProcessor } from './processor/types';
+import type {
+  AudioProcessorOptions,
+  TrackProcessor,
+  VideoProcessorOptions,
+} from './processor/types';
 import {
   constraintsForOptions,
   mergeDefaultOptions,
   screenCaptureToDisplayMediaStreamOptions,
 } from './utils';
 
+/** @internal */
+export function extractProcessorsFromOptions(options: CreateLocalTracksOptions) {
+  let audioProcessor: TrackProcessor<Track.Kind.Audio, AudioProcessorOptions> | undefined;
+  let videoProcessor: TrackProcessor<Track.Kind.Video, VideoProcessorOptions> | undefined;
+
+  if (typeof options.audio === 'object' && options.audio.processor) {
+    audioProcessor = options.audio.processor;
+  }
+  if (typeof options.video === 'object' && options.video.processor) {
+    videoProcessor = options.video.processor;
+  }
+
+  return { audioProcessor, videoProcessor };
+}
+
 /**
  * Creates a local video and audio track at the same time. When acquiring both
  * audio and video tracks together, it'll display a single permission prompt to
@@ -35,6 +54,7 @@ export async function createLocalTracks(
   options.audio ??= true;
   options.video ??= true;
 
+  const { audioProcessor, videoProcessor } = extractProcessorsFromOptions(options);
   const opts = mergeDefaultOptions(options, audioDefaults, videoDefaults);
   const constraints = constraintsForOptions(opts);
 
@@ -55,7 +75,7 @@ export async function createLocalTracks(
   return Promise.all(
     stream.getTracks().map(async (mediaStreamTrack) => {
       const isAudio = mediaStreamTrack.kind === 'audio';
-      let trackOptions = isAudio ? options!.audio : options!.video;
+      let trackOptions = isAudio ? opts!.audio : opts!.video;
       if (typeof trackOptions === 'boolean' || !trackOptions) {
         trackOptions = {};
       }
@@ -80,13 +100,12 @@ export async function createLocalTracks(
         track.source = Track.Source.Microphone;
       }
       track.mediaStream = stream;
-      if (trackOptions.processor) {
-        if (track instanceof LocalAudioTrack) {
-          await track.setProcessor(trackOptions.processor as TrackProcessor<Track.Kind.Audio>);
-        } else if (track instanceof LocalVideoTrack) {
-          await track.setProcessor(trackOptions.processor as TrackProcessor<Track.Kind.Video>);
-        }
+      if (track instanceof LocalAudioTrack && audioProcessor) {
+        await track.setProcessor(audioProcessor);
+      } else if (track instanceof LocalVideoTrack && videoProcessor) {
+        await track.setProcessor(videoProcessor);
       }
+
       return track;
     }),
   );

package/src/room/track/options.ts

@@ -64,7 +64,7 @@ export interface TrackPublishDefaults {
   simulcast?: boolean;
 
   /**
-   * scalability mode for svc codecs, defaults to 'L3T3'.
+   * scalability mode for svc codecs, defaults to 'L3T3_KEY'.
    * for svc codecs, simulcast is disabled.
    */
   scalabilityMode?: ScalabilityMode;

package/src/room/types.ts

@@ -65,4 +65,6 @@ export interface TranscriptionSegment {
   startTime: number;
   endTime: number;
   final: boolean;
+  firstReceivedTime: number;
+  lastReceivedTime: number;
 }

package/src/room/utils.ts

@@ -532,8 +532,16 @@ export function toHttpUrl(url: string): string {
 
 export function extractTranscriptionSegments(
   transcription: TranscriptionModel,
+  firstReceivedTimesMap: Map<string, number>,
 ): TranscriptionSegment[] {
   return transcription.segments.map(({ id, text, language, startTime, endTime, final }) => {
+    const firstReceivedTime = firstReceivedTimesMap.get(id) ?? Date.now();
+    const lastReceivedTime = Date.now();
+    if (final) {
+      firstReceivedTimesMap.delete(id);
+    } else {
+      firstReceivedTimesMap.set(id, firstReceivedTime);
+    }
     return {
       id,
       text,
@@ -541,6 +549,8 @@ export function extractTranscriptionSegments(
       endTime: Number.parseInt(endTime.toString()),
       final,
       language,
+      firstReceivedTime,
+      lastReceivedTime,
     };
   });
 }