livekit-client 1.1.8 → 1.2.1

package/src/proto/livekit_models.ts

@@ -213,6 +213,68 @@ export function clientConfigSettingToJSON(object: ClientConfigSetting): string {
   }
 }
 
+export enum DisconnectReason {
+  UNKNOWN_REASON = 0,
+  CLIENT_INITIATED = 1,
+  DUPLICATE_IDENTITY = 2,
+  SERVER_SHUTDOWN = 3,
+  PARTICIPANT_REMOVED = 4,
+  ROOM_DELETED = 5,
+  STATE_MISMATCH = 6,
+  UNRECOGNIZED = -1,
+}
+
+export function disconnectReasonFromJSON(object: any): DisconnectReason {
+  switch (object) {
+    case 0:
+    case 'UNKNOWN_REASON':
+      return DisconnectReason.UNKNOWN_REASON;
+    case 1:
+    case 'CLIENT_INITIATED':
+      return DisconnectReason.CLIENT_INITIATED;
+    case 2:
+    case 'DUPLICATE_IDENTITY':
+      return DisconnectReason.DUPLICATE_IDENTITY;
+    case 3:
+    case 'SERVER_SHUTDOWN':
+      return DisconnectReason.SERVER_SHUTDOWN;
+    case 4:
+    case 'PARTICIPANT_REMOVED':
+      return DisconnectReason.PARTICIPANT_REMOVED;
+    case 5:
+    case 'ROOM_DELETED':
+      return DisconnectReason.ROOM_DELETED;
+    case 6:
+    case 'STATE_MISMATCH':
+      return DisconnectReason.STATE_MISMATCH;
+    case -1:
+    case 'UNRECOGNIZED':
+    default:
+      return DisconnectReason.UNRECOGNIZED;
+  }
+}
+
+export function disconnectReasonToJSON(object: DisconnectReason): string {
+  switch (object) {
+    case DisconnectReason.UNKNOWN_REASON:
+      return 'UNKNOWN_REASON';
+    case DisconnectReason.CLIENT_INITIATED:
+      return 'CLIENT_INITIATED';
+    case DisconnectReason.DUPLICATE_IDENTITY:
+      return 'DUPLICATE_IDENTITY';
+    case DisconnectReason.SERVER_SHUTDOWN:
+      return 'SERVER_SHUTDOWN';
+    case DisconnectReason.PARTICIPANT_REMOVED:
+      return 'PARTICIPANT_REMOVED';
+    case DisconnectReason.ROOM_DELETED:
+      return 'ROOM_DELETED';
+    case DisconnectReason.STATE_MISMATCH:
+      return 'STATE_MISMATCH';
+    default:
+      return 'UNKNOWN';
+  }
+}
+
 export interface Room {
   sid: string;
   name: string;
@@ -315,6 +377,7 @@ export interface SimulcastCodecInfo {
   mimeType: string;
   mid: string;
   cid: string;
+  layers: VideoLayer[];
 }
 
 export interface TrackInfo {
@@ -499,12 +562,17 @@ export interface ClientConfiguration {
   video?: VideoConfiguration;
   screen?: VideoConfiguration;
   resumeConnection: ClientConfigSetting;
+  disabledCodecs?: DisabledCodecs;
 }
 
 export interface VideoConfiguration {
   hardwareEncoder: ClientConfigSetting;
 }
 
+export interface DisabledCodecs {
+  codecs: Codec[];
+}
+
 export interface RTPStats {
   startTime?: Date;
   endTime?: Date;
@@ -531,7 +599,9 @@ export interface RTPStats {
   jitterMax: number;
   gapHistogram: { [key: number]: number };
   nacks: number;
+  nackAcks: number;
   nackMisses: number;
+  nackRepeated: number;
   plis: number;
   lastPli?: Date;
   firs: number;
@@ -1015,7 +1085,7 @@ export const ParticipantInfo = {
 };
 
 function createBaseSimulcastCodecInfo(): SimulcastCodecInfo {
-  return { mimeType: '', mid: '', cid: '' };
+  return { mimeType: '', mid: '', cid: '', layers: [] };
 }
 
 export const SimulcastCodecInfo = {
@@ -1029,6 +1099,9 @@ export const SimulcastCodecInfo = {
     if (message.cid !== '') {
       writer.uint32(26).string(message.cid);
     }
+    for (const v of message.layers) {
+      VideoLayer.encode(v!, writer.uint32(34).fork()).ldelim();
+    }
     return writer;
   },
 
@@ -1048,6 +1121,9 @@ export const SimulcastCodecInfo = {
         case 3:
           message.cid = reader.string();
           break;
+        case 4:
+          message.layers.push(VideoLayer.decode(reader, reader.uint32()));
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -1061,6 +1137,9 @@ export const SimulcastCodecInfo = {
       mimeType: isSet(object.mimeType) ? String(object.mimeType) : '',
       mid: isSet(object.mid) ? String(object.mid) : '',
       cid: isSet(object.cid) ? String(object.cid) : '',
+      layers: Array.isArray(object?.layers)
+        ? object.layers.map((e: any) => VideoLayer.fromJSON(e))
+        : [],
     };
   },
 
@@ -1069,6 +1148,11 @@ export const SimulcastCodecInfo = {
     message.mimeType !== undefined && (obj.mimeType = message.mimeType);
     message.mid !== undefined && (obj.mid = message.mid);
     message.cid !== undefined && (obj.cid = message.cid);
+    if (message.layers) {
+      obj.layers = message.layers.map((e) => (e ? VideoLayer.toJSON(e) : undefined));
+    } else {
+      obj.layers = [];
+    }
     return obj;
   },
 
@@ -1077,6 +1161,7 @@ export const SimulcastCodecInfo = {
     message.mimeType = object.mimeType ?? '';
     message.mid = object.mid ?? '';
     message.cid = object.cid ?? '';
+    message.layers = object.layers?.map((e) => VideoLayer.fromPartial(e)) || [];
     return message;
   },
 };
@@ -1820,7 +1905,7 @@ export const ClientInfo = {
 };
 
 function createBaseClientConfiguration(): ClientConfiguration {
-  return { video: undefined, screen: undefined, resumeConnection: 0 };
+  return { video: undefined, screen: undefined, resumeConnection: 0, disabledCodecs: undefined };
 }
 
 export const ClientConfiguration = {
@@ -1834,6 +1919,9 @@ export const ClientConfiguration = {
     if (message.resumeConnection !== 0) {
       writer.uint32(24).int32(message.resumeConnection);
     }
+    if (message.disabledCodecs !== undefined) {
+      DisabledCodecs.encode(message.disabledCodecs, writer.uint32(34).fork()).ldelim();
+    }
     return writer;
   },
 
@@ -1853,6 +1941,9 @@ export const ClientConfiguration = {
         case 3:
           message.resumeConnection = reader.int32() as any;
           break;
+        case 4:
+          message.disabledCodecs = DisabledCodecs.decode(reader, reader.uint32());
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -1868,6 +1959,9 @@ export const ClientConfiguration = {
       resumeConnection: isSet(object.resumeConnection)
         ? clientConfigSettingFromJSON(object.resumeConnection)
         : 0,
+      disabledCodecs: isSet(object.disabledCodecs)
+        ? DisabledCodecs.fromJSON(object.disabledCodecs)
+        : undefined,
     };
   },
 
@@ -1879,6 +1973,10 @@ export const ClientConfiguration = {
       (obj.screen = message.screen ? VideoConfiguration.toJSON(message.screen) : undefined);
     message.resumeConnection !== undefined &&
       (obj.resumeConnection = clientConfigSettingToJSON(message.resumeConnection));
+    message.disabledCodecs !== undefined &&
+      (obj.disabledCodecs = message.disabledCodecs
+        ? DisabledCodecs.toJSON(message.disabledCodecs)
+        : undefined);
     return obj;
   },
 
@@ -1895,6 +1993,10 @@ export const ClientConfiguration = {
         ? VideoConfiguration.fromPartial(object.screen)
         : undefined;
     message.resumeConnection = object.resumeConnection ?? 0;
+    message.disabledCodecs =
+      object.disabledCodecs !== undefined && object.disabledCodecs !== null
+        ? DisabledCodecs.fromPartial(object.disabledCodecs)
+        : undefined;
     return message;
   },
 };
@@ -1951,6 +2053,59 @@ export const VideoConfiguration = {
   },
 };
 
+function createBaseDisabledCodecs(): DisabledCodecs {
+  return { codecs: [] };
+}
+
+export const DisabledCodecs = {
+  encode(message: DisabledCodecs, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.codecs) {
+      Codec.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): DisabledCodecs {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDisabledCodecs();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.codecs.push(Codec.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DisabledCodecs {
+    return {
+      codecs: Array.isArray(object?.codecs) ? object.codecs.map((e: any) => Codec.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: DisabledCodecs): unknown {
+    const obj: any = {};
+    if (message.codecs) {
+      obj.codecs = message.codecs.map((e) => (e ? Codec.toJSON(e) : undefined));
+    } else {
+      obj.codecs = [];
+    }
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<DisabledCodecs>, I>>(object: I): DisabledCodecs {
+    const message = createBaseDisabledCodecs();
+    message.codecs = object.codecs?.map((e) => Codec.fromPartial(e)) || [];
+    return message;
+  },
+};
+
 function createBaseRTPStats(): RTPStats {
   return {
     startTime: undefined,
@@ -1978,7 +2133,9 @@ function createBaseRTPStats(): RTPStats {
     jitterMax: 0,
     gapHistogram: {},
     nacks: 0,
+    nackAcks: 0,
     nackMisses: 0,
+    nackRepeated: 0,
     plis: 0,
     lastPli: undefined,
     firs: 0,
@@ -2072,9 +2229,15 @@ export const RTPStats = {
     if (message.nacks !== 0) {
       writer.uint32(200).uint32(message.nacks);
     }
+    if (message.nackAcks !== 0) {
+      writer.uint32(296).uint32(message.nackAcks);
+    }
     if (message.nackMisses !== 0) {
       writer.uint32(208).uint32(message.nackMisses);
     }
+    if (message.nackRepeated !== 0) {
+      writer.uint32(304).uint32(message.nackRepeated);
+    }
     if (message.plis !== 0) {
       writer.uint32(216).uint32(message.plis);
     }
@@ -2193,9 +2356,15 @@ export const RTPStats = {
         case 25:
           message.nacks = reader.uint32();
           break;
+        case 37:
+          message.nackAcks = reader.uint32();
+          break;
         case 26:
           message.nackMisses = reader.uint32();
           break;
+        case 38:
+          message.nackRepeated = reader.uint32();
+          break;
         case 27:
           message.plis = reader.uint32();
           break;
@@ -2273,7 +2442,9 @@ export const RTPStats = {
           )
         : {},
       nacks: isSet(object.nacks) ? Number(object.nacks) : 0,
+      nackAcks: isSet(object.nackAcks) ? Number(object.nackAcks) : 0,
       nackMisses: isSet(object.nackMisses) ? Number(object.nackMisses) : 0,
+      nackRepeated: isSet(object.nackRepeated) ? Number(object.nackRepeated) : 0,
       plis: isSet(object.plis) ? Number(object.plis) : 0,
       lastPli: isSet(object.lastPli) ? fromJsonTimestamp(object.lastPli) : undefined,
       firs: isSet(object.firs) ? Number(object.firs) : 0,
@@ -2327,7 +2498,9 @@ export const RTPStats = {
       });
     }
     message.nacks !== undefined && (obj.nacks = Math.round(message.nacks));
+    message.nackAcks !== undefined && (obj.nackAcks = Math.round(message.nackAcks));
     message.nackMisses !== undefined && (obj.nackMisses = Math.round(message.nackMisses));
+    message.nackRepeated !== undefined && (obj.nackRepeated = Math.round(message.nackRepeated));
     message.plis !== undefined && (obj.plis = Math.round(message.plis));
     message.lastPli !== undefined && (obj.lastPli = message.lastPli.toISOString());
     message.firs !== undefined && (obj.firs = Math.round(message.firs));
@@ -2376,7 +2549,9 @@ export const RTPStats = {
       return acc;
     }, {});
     message.nacks = object.nacks ?? 0;
+    message.nackAcks = object.nackAcks ?? 0;
     message.nackMisses = object.nackMisses ?? 0;
+    message.nackRepeated = object.nackRepeated ?? 0;
     message.plis = object.plis ?? 0;
     message.lastPli = object.lastPli ?? undefined;
     message.firs = object.firs ?? 0;
@@ -2480,9 +2655,9 @@ const btoa: (bin: string) => string =
   globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, 'binary').toString('base64'));
 function base64FromBytes(arr: Uint8Array): string {
   const bin: string[] = [];
-  arr.forEach((byte) => {
+  for (const byte of arr) {
     bin.push(String.fromCharCode(byte));
-  });
+  }
   return btoa(bin.join(''));
 }
 

package/src/proto/livekit_rtc.ts

@@ -9,6 +9,7 @@ import {
   ClientConfiguration,
   TrackInfo,
   VideoQuality,
+  DisconnectReason,
   ConnectionQuality,
   VideoLayer,
   ParticipantTracks,
@@ -19,6 +20,8 @@ import {
   trackSourceToJSON,
   videoQualityFromJSON,
   videoQualityToJSON,
+  disconnectReasonFromJSON,
+  disconnectReasonToJSON,
   connectionQualityFromJSON,
   connectionQualityToJSON,
 } from './livekit_models';
@@ -283,6 +286,7 @@ export interface LeaveRequest {
    * indicates clients should attempt full-reconnect sequence
    */
   canReconnect: boolean;
+  reason: DisconnectReason;
 }
 
 /** message to indicate published video track dimensions are changing */
@@ -1836,7 +1840,7 @@ export const UpdateTrackSettings = {
 };
 
 function createBaseLeaveRequest(): LeaveRequest {
-  return { canReconnect: false };
+  return { canReconnect: false, reason: 0 };
 }
 
 export const LeaveRequest = {
@@ -1844,6 +1848,9 @@ export const LeaveRequest = {
     if (message.canReconnect === true) {
       writer.uint32(8).bool(message.canReconnect);
     }
+    if (message.reason !== 0) {
+      writer.uint32(16).int32(message.reason);
+    }
     return writer;
   },
 
@@ -1857,6 +1864,9 @@ export const LeaveRequest = {
         case 1:
           message.canReconnect = reader.bool();
           break;
+        case 2:
+          message.reason = reader.int32() as any;
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -1868,18 +1878,21 @@ export const LeaveRequest = {
   fromJSON(object: any): LeaveRequest {
     return {
       canReconnect: isSet(object.canReconnect) ? Boolean(object.canReconnect) : false,
+      reason: isSet(object.reason) ? disconnectReasonFromJSON(object.reason) : 0,
     };
   },
 
   toJSON(message: LeaveRequest): unknown {
     const obj: any = {};
     message.canReconnect !== undefined && (obj.canReconnect = message.canReconnect);
+    message.reason !== undefined && (obj.reason = disconnectReasonToJSON(message.reason));
     return obj;
   },
 
   fromPartial<I extends Exact<DeepPartial<LeaveRequest>, I>>(object: I): LeaveRequest {
     const message = createBaseLeaveRequest();
     message.canReconnect = object.canReconnect ?? false;
+    message.reason = object.reason ?? 0;
     return message;
   },
 };

package/src/room/PCTransport.ts

@@ -1,6 +1,13 @@
 import { debounce } from 'ts-debounce';
 import log from '../logger';
 
+/** @internal */
+interface TrackBitrateInfo {
+  sid: string;
+  codec: string;
+  maxbr: number;
+}
+
 /** @internal */
 export default class PCTransport {
   pc: RTCPeerConnection;
@@ -11,6 +18,8 @@ export default class PCTransport {
 
   renegotiate: boolean = false;
 
+  trackBitrates: TrackBitrateInfo[] = [];
+
   onOffer?: (offer: RTCSessionDescriptionInit) => void;
 
   constructor(config?: RTCConfiguration) {
@@ -78,10 +87,40 @@ export default class PCTransport {
     // actually negotiate
     log.debug('starting to negotiate');
     const offer = await this.pc.createOffer(options);
+
+    // mung sdp for codec bitrate setting that can't apply by sendEncoding
+    this.trackBitrates.forEach((trackbr) => {
+      let sdp = offer.sdp ?? '';
+      const sidIndex = sdp.search(new RegExp(`msid.* ${trackbr.sid}`));
+      if (sidIndex < 0) {
+        return;
+      }
+
+      const mlineStart = sdp.substring(0, sidIndex).lastIndexOf('m=');
+      const mlineEnd = sdp.indexOf('m=', sidIndex);
+      const mediaSection = sdp.substring(mlineStart, mlineEnd);
+
+      const mungedMediaSection = mediaSection.replace(
+        new RegExp(`a=rtpmap:(\\d+) ${trackbr.codec}/\\d+`, 'i'),
+        `$&\r\na=fmtp:$1 x-google-max-bitrate=${trackbr.maxbr}`,
+      );
+      sdp = sdp.substring(0, mlineStart) + mungedMediaSection + sdp.substring(mlineEnd);
+      offer.sdp = sdp;
+    });
+    this.trackBitrates = [];
+
     await this.pc.setLocalDescription(offer);
     this.onOffer(offer);
   }
 
+  setTrackCodecBitrate(sid: string, codec: string, maxbr: number) {
+    this.trackBitrates.push({
+      sid,
+      codec,
+      maxbr,
+    });
+  }
+
   close() {
     this.pc.close();
   }

package/src/room/RTCEngine.ts

@@ -7,6 +7,7 @@ import {
   ClientConfiguration,
   DataPacket,
   DataPacket_Kind,
+  DisconnectReason,
   SpeakerInfo,
   TrackInfo,
   UserPacket,
@@ -276,23 +277,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         this.emit(EngineEvent.MediaTrackAdded, track, ev.stream);
       };
     }
-    // data channels
-    this.lossyDC = this.publisher.pc.createDataChannel(lossyDataChannel, {
-      // will drop older packets that arrive
-      ordered: true,
-      maxRetransmits: 0,
-    });
-    this.reliableDC = this.publisher.pc.createDataChannel(reliableDataChannel, {
-      ordered: true,
-    });
 
-    // also handle messages over the pub channel, for backwards compatibility
-    this.lossyDC.onmessage = this.handleDataMessage;
-    this.reliableDC.onmessage = this.handleDataMessage;
-
-    // handle datachannel errors
-    this.lossyDC.onerror = this.handleDataError;
-    this.reliableDC.onerror = this.handleDataError;
+    this.createDataChannels();
 
     // configure signaling client
     this.client.onAnswer = async (sd) => {
@@ -360,13 +346,47 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         this.fullReconnectOnNext = true;
         this.primaryPC = undefined;
       } else {
-        this.emit(EngineEvent.Disconnected);
+        this.emit(EngineEvent.Disconnected, leave?.reason);
         this.close();
       }
       log.trace('leave request', { leave });
     };
   }
 
+  private createDataChannels() {
+    if (!this.publisher) {
+      return;
+    }
+
+    // clear old data channel callbacks if recreate
+    if (this.lossyDC) {
+      this.lossyDC.onmessage = null;
+      this.lossyDC.onerror = null;
+    }
+    if (this.reliableDC) {
+      this.reliableDC.onmessage = null;
+      this.reliableDC.onerror = null;
+    }
+
+    // create data channels
+    this.lossyDC = this.publisher.pc.createDataChannel(lossyDataChannel, {
+      // will drop older packets that arrive
+      ordered: true,
+      maxRetransmits: 0,
+    });
+    this.reliableDC = this.publisher.pc.createDataChannel(reliableDataChannel, {
+      ordered: true,
+    });
+
+    // also handle messages over the pub channel, for backwards compatibility
+    this.lossyDC.onmessage = this.handleDataMessage;
+    this.reliableDC.onmessage = this.handleDataMessage;
+
+    // handle datachannel errors
+    this.lossyDC.onerror = this.handleDataError;
+    this.reliableDC.onerror = this.handleDataError;
+  }
+
   private handleDataChannel = async ({ channel }: RTCDataChannelEvent) => {
     if (!channel) {
       return;
@@ -562,6 +582,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     await this.waitForPCConnected();
     this.client.setReconnected();
 
+    // recreate publish datachannel if it's id is null
+    // (for safari https://bugs.webkit.org/show_bug.cgi?id=184688)
+    if (this.reliableDC?.readyState === 'open' && this.reliableDC.id === null) {
+      this.createDataChannels();
+    }
+
     // resume success
     this.emit(EngineEvent.Resumed);
   }
@@ -716,7 +742,7 @@ class SignalReconnectError extends Error {}
 
 export type EngineEventCallbacks = {
   connected: () => void;
-  disconnected: () => void;
+  disconnected: (reason?: DisconnectReason) => void;
   resuming: () => void;
   resumed: () => void;
   restarting: () => void;