livekit-client 2.13.4 → 2.13.6

package/src/room/track/LocalVideoTrack.ts

@@ -7,12 +7,11 @@ import {
 } from '@livekit/protocol';
 import type { SignalClient } from '../../api/SignalClient';
 import type { StructuredLogger } from '../../logger';
-import { getBrowser } from '../../utils/browserParser';
 import { ScalabilityMode } from '../participant/publishUtils';
 import type { VideoSenderStats } from '../stats';
 import { computeBitrate, monitorFrequency } from '../stats';
 import type { LoggerOptions } from '../types';
-import { compareVersions, isFireFox, isMobile, isSVCCodec, isWeb } from '../utils';
+import { isFireFox, isMobile, isSVCCodec, isWeb } from '../utils';
 import LocalTrack from './LocalTrack';
 import { Track, VideoQuality } from './Track';
 import type { VideoCaptureOptions, VideoCodec } from './options';
@@ -459,15 +458,18 @@ async function setPublishingLayersForSender(
     }
 
     let hasChanged = false;
-    const browser = getBrowser();
-    const closableSpatial =
-      browser?.name === 'Chrome' && compareVersions(browser?.version, '133') > 0;
+
+    /* disable closable spatial layer as it has video blur / frozen issue with current server / client
+    1. chrome 113: when switching to up layer with scalability Mode change, it will generate a
+          low resolution frame and recover very quickly, but noticable
+    2. livekit sfu: additional pli request cause video frozen for a few frames, also noticable */
+    const closableSpatial = false;
     /* @ts-ignore */
     if (closableSpatial && encodings[0].scalabilityMode) {
       // svc dynacast encodings
       const encoding = encodings[0];
       /* @ts-ignore */
-      const mode = new ScalabilityMode(encoding.scalabilityMode);
+      // const mode = new ScalabilityMode(encoding.scalabilityMode);
       let maxQuality = ProtoVideoQuality.OFF;
       qualities.forEach((q) => {
         if (q.enabled && (maxQuality === ProtoVideoQuality.OFF || q.quality > maxQuality)) {
@@ -480,25 +482,22 @@ async function setPublishingLayersForSender(
           encoding.active = false;
           hasChanged = true;
         }
-      } else if (!encoding.active || mode.spatial !== maxQuality + 1) {
+      } else if (!encoding.active /* || mode.spatial !== maxQuality + 1*/) {
         hasChanged = true;
         encoding.active = true;
-        /* @ts-ignore */
-        const originalMode = new ScalabilityMode(senderEncodings[0].scalabilityMode);
+        /*
+        @ts-ignore
+        const originalMode = new ScalabilityMode(senderEncodings[0].scalabilityMode)
         mode.spatial = maxQuality + 1;
         mode.suffix = originalMode.suffix;
         if (mode.spatial === 1) {
           // no suffix for L1Tx
           mode.suffix = undefined;
         }
-        /* @ts-ignore */
+        @ts-ignore
         encoding.scalabilityMode = mode.toString();
         encoding.scaleResolutionDownBy = 2 ** (2 - maxQuality);
-        if (senderEncodings[0].maxBitrate) {
-          encoding.maxBitrate =
-            senderEncodings[0].maxBitrate /
-            (encoding.scaleResolutionDownBy * encoding.scaleResolutionDownBy);
-        }
+      */
       }
     } else {
       if (isSVC) {

package/src/utils/dataPacketBuffer.ts

@@ -0,0 +1,52 @@
+export interface DataPacketItem {
+  data: Uint8Array;
+  sequence: number;
+}
+
+export class DataPacketBuffer {
+  private buffer: DataPacketItem[] = [];
+
+  private _totalSize = 0;
+
+  push(item: DataPacketItem) {
+    this.buffer.push(item);
+    this._totalSize += item.data.byteLength;
+  }
+
+  pop(): DataPacketItem | undefined {
+    const item = this.buffer.shift();
+    if (item) {
+      this._totalSize -= item.data.byteLength;
+    }
+    return item;
+  }
+
+  getAll(): DataPacketItem[] {
+    return this.buffer.slice();
+  }
+
+  popToSequence(sequence: number) {
+    while (this.buffer.length > 0) {
+      const first = this.buffer[0];
+      if (first.sequence <= sequence) {
+        this.pop();
+      } else {
+        break;
+      }
+    }
+  }
+
+  alignBufferedAmount(bufferedAmount: number) {
+    while (this.buffer.length > 0) {
+      const first = this.buffer[0];
+      if (this._totalSize - first.data.byteLength <= bufferedAmount) {
+        break;
+      }
+      this.pop();
+    }
+  }
+
+  get length(): number {
+    return this.buffer.length;
+  }
+}

package/src/utils/ttlmap.ts

@@ -0,0 +1,96 @@
+export class TTLMap<K, V> {
+  private _map = new Map<K, { value: V; expiresAt: number }>();
+
+  private ttl: number;
+
+  private _lastCleanup = 0;
+
+  /**
+   * @param ttl ttl of the key (ms)
+   */
+  constructor(ttl: number) {
+    this.ttl = ttl;
+  }
+
+  set(key: K, value: V) {
+    const now = Date.now();
+    if (now - this._lastCleanup > this.ttl / 2) {
+      this.cleanup();
+    }
+    const expiresAt = now + this.ttl;
+    this._map.set(key, { value, expiresAt });
+    return this;
+  }
+
+  get(key: K): V | undefined {
+    const entry = this._map.get(key);
+    if (!entry) return undefined;
+    if (entry.expiresAt < Date.now()) {
+      this._map.delete(key);
+      return undefined;
+    }
+    return entry.value;
+  }
+
+  has(key: K): boolean {
+    const entry = this._map.get(key);
+    if (!entry) return false;
+    if (entry.expiresAt < Date.now()) {
+      this._map.delete(key);
+      return false;
+    }
+    return true;
+  }
+
+  delete(key: K): boolean {
+    return this._map.delete(key);
+  }
+
+  clear() {
+    this._map.clear();
+  }
+
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this._map.entries()) {
+      if (entry.expiresAt < now) {
+        this._map.delete(key);
+      }
+    }
+    this._lastCleanup = now;
+  }
+
+  get size() {
+    this.cleanup();
+    return this._map.size;
+  }
+
+  forEach(callback: (value: V, key: K, map: Map<K, V>) => void) {
+    this.cleanup();
+    for (const [key, entry] of this._map.entries()) {
+      if (entry.expiresAt >= Date.now()) {
+        callback(entry.value, key, this.asValueMap());
+      }
+    }
+  }
+
+  map<U>(callback: (value: V, key: K, map: Map<K, V>) => U): U[] {
+    this.cleanup();
+    const result: U[] = [];
+    const valueMap = this.asValueMap();
+    for (const [key, value] of valueMap.entries()) {
+      result.push(callback(value, key, valueMap));
+    }
+    return result;
+  }
+
+  private asValueMap(): Map<K, V> {
+    const result = new Map<K, V>();
+    for (const [key, entry] of this._map.entries()) {
+      if (entry.expiresAt >= Date.now()) {
+        result.set(key, entry.value);
+      }
+    }
+    return result;
+  }
+}