livekit-client 0.17.4 → 0.17.6-rc2

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

@@ -1,70 +0,0 @@
-import { VideoQuality } from '../../proto/livekit_models';
-import { videoLayersFromEncodings } from './LocalVideoTrack';
-
-describe('videoLayersFromEncodings', () => {
-  it('returns single layer for no encoding', () => {
-    const layers = videoLayersFromEncodings(640, 360);
-    expect(layers).toHaveLength(1);
-    expect(layers[0].quality).toBe(VideoQuality.HIGH);
-    expect(layers[0].width).toBe(640);
-    expect(layers[0].height).toBe(360);
-  });
-
-  it('returns single layer for explicit encoding', () => {
-    const layers = videoLayersFromEncodings(640, 360, [{
-      maxBitrate: 200_000,
-    }]);
-    expect(layers).toHaveLength(1);
-    expect(layers[0].quality).toBe(VideoQuality.HIGH);
-    expect(layers[0].bitrate).toBe(200_000);
-  });
-
-  it('returns three layers for simulcast', () => {
-    const layers = videoLayersFromEncodings(1280, 720, [
-      {
-        scaleResolutionDownBy: 4,
-        rid: 'q',
-        maxBitrate: 125_000,
-      },
-      {
-        scaleResolutionDownBy: 2,
-        rid: 'h',
-        maxBitrate: 500_000,
-      },
-      {
-        rid: 'f',
-        maxBitrate: 1_200_000,
-      },
-    ]);
-
-    expect(layers).toHaveLength(3);
-    expect(layers[0].quality).toBe(VideoQuality.LOW);
-    expect(layers[0].width).toBe(320);
-    expect(layers[2].quality).toBe(VideoQuality.HIGH);
-    expect(layers[2].height).toBe(720);
-  });
-
-  it('handles portrait', () => {
-    const layers = videoLayersFromEncodings(720, 1280, [
-      {
-        scaleResolutionDownBy: 4,
-        rid: 'q',
-        maxBitrate: 125_000,
-      },
-      {
-        scaleResolutionDownBy: 2,
-        rid: 'h',
-        maxBitrate: 500_000,
-      },
-      {
-        rid: 'f',
-        maxBitrate: 1_200_000,
-      },
-    ]);
-    expect(layers).toHaveLength(3);
-    expect(layers[0].quality).toBe(VideoQuality.LOW);
-    expect(layers[0].height).toBe(320);
-    expect(layers[2].quality).toBe(VideoQuality.HIGH);
-    expect(layers[2].width).toBe(720);
-  });
-});

package/src/room/track/LocalVideoTrack.ts

@@ -1,293 +0,0 @@
-import { SignalClient } from '../../api/SignalClient';
-import log from '../../logger';
-import { VideoLayer, VideoQuality } from '../../proto/livekit_models';
-import { SubscribedQuality } from '../../proto/livekit_rtc';
-import { computeBitrate, monitorFrequency, VideoSenderStats } from '../stats';
-import { isFireFox, isMobile } from '../utils';
-import LocalTrack from './LocalTrack';
-import { VideoCaptureOptions } from './options';
-import { Track } from './Track';
-import { constraintsForOptions } from './utils';
-
-export default class LocalVideoTrack extends LocalTrack {
-  /* internal */
-  signalClient?: SignalClient;
-
-  private prevStats?: Map<string, VideoSenderStats>;
-
-  private encodings?: RTCRtpEncodingParameters[];
-
-  constructor(
-    mediaTrack: MediaStreamTrack,
-    constraints?: MediaTrackConstraints,
-  ) {
-    super(mediaTrack, Track.Kind.Video, constraints);
-  }
-
-  get isSimulcast(): boolean {
-    if (this.sender && this.sender.getParameters().encodings.length > 1) {
-      return true;
-    }
-    return false;
-  }
-
-  /* @internal */
-  startMonitor(signalClient: SignalClient) {
-    this.signalClient = signalClient;
-    // save original encodings
-    const params = this.sender?.getParameters();
-    if (params) {
-      this.encodings = params.encodings;
-    }
-
-    setTimeout(() => {
-      this.monitorSender();
-    }, monitorFrequency);
-  }
-
-  stop() {
-    this.sender = undefined;
-    this.mediaStreamTrack.getConstraints();
-    super.stop();
-  }
-
-  async mute(): Promise<LocalVideoTrack> {
-    if (this.source === Track.Source.Camera) {
-      log.debug('stopping camera track');
-      // also stop the track, so that camera indicator is turned off
-      this.mediaStreamTrack.stop();
-    }
-    await super.mute();
-    return this;
-  }
-
-  async unmute(): Promise<LocalVideoTrack> {
-    if (this.source === Track.Source.Camera) {
-      log.debug('reacquiring camera track');
-      await this.restartTrack();
-    }
-    await super.unmute();
-    return this;
-  }
-
-  async getSenderStats(): Promise<VideoSenderStats[]> {
-    if (!this.sender) {
-      return [];
-    }
-
-    const items: VideoSenderStats[] = [];
-
-    const stats = await this.sender.getStats();
-    stats.forEach((v) => {
-      if (v.type === 'outbound-rtp') {
-        const vs: VideoSenderStats = {
-          type: 'video',
-          streamId: v.id,
-          frameHeight: v.frameHeight,
-          frameWidth: v.frameWidth,
-          firCount: v.firCount,
-          pliCount: v.pliCount,
-          nackCount: v.nackCount,
-          packetsSent: v.packetsSent,
-          bytesSent: v.bytesSent,
-          framesSent: v.framesSent,
-          timestamp: v.timestamp,
-          rid: v.rid ?? '',
-          retransmittedPacketsSent: v.retransmittedPacketsSent,
-          qualityLimitationReason: v.qualityLimitationReason,
-          qualityLimitationResolutionChanges:
-            v.qualityLimitationResolutionChanges,
-        };
-
-        // locate the appropriate remote-inbound-rtp item
-        const r = stats.get(v.remoteId);
-        if (r) {
-          vs.jitter = r.jitter;
-          vs.packetsLost = r.packetsLost;
-          vs.roundTripTime = r.roundTripTime;
-        }
-
-        items.push(vs);
-      }
-    });
-
-    return items;
-  }
-
-  setPublishingQuality(maxQuality: VideoQuality) {
-    const qualities: SubscribedQuality[] = [];
-    for (let q = VideoQuality.LOW; q <= VideoQuality.HIGH; q += 1) {
-      qualities.push({
-        quality: q,
-        enabled: q <= maxQuality,
-      });
-    }
-    log.debug('setting publishing quality. max quality', maxQuality);
-    this.setPublishingLayers(qualities);
-  }
-
-  async setDeviceId(deviceId: string) {
-    if (this.constraints.deviceId === deviceId) {
-      return;
-    }
-    this.constraints.deviceId = deviceId;
-    // when video is muted, underlying media stream track is stopped and
-    // will be restarted later
-    if (!this.isMuted) {
-      await this.restartTrack();
-    }
-  }
-
-  async restartTrack(options?: VideoCaptureOptions) {
-    let constraints: MediaTrackConstraints | undefined;
-    if (options) {
-      const streamConstraints = constraintsForOptions({ video: options });
-      if (typeof streamConstraints.video !== 'boolean') {
-        constraints = streamConstraints.video;
-      }
-    }
-    await this.restart(constraints);
-  }
-
-  /**
-   * @internal
-   * Sets layers that should be publishing
-   */
-  async setPublishingLayers(qualities: SubscribedQuality[]) {
-    log.debug('setting publishing layers', qualities);
-    if (!this.sender || !this.encodings) {
-      return;
-    }
-    const params = this.sender.getParameters();
-    const { encodings } = params;
-    if (!encodings) {
-      return;
-    }
-
-    if (encodings.length !== this.encodings.length) {
-      log.warn('cannot set publishing layers, encodings mismatch');
-      return;
-    }
-
-    let hasChanged = false;
-    encodings.forEach((encoding, idx) => {
-      let rid = encoding.rid ?? '';
-      if (rid === '') {
-        rid = 'q';
-      }
-      const quality = videoQualityForRid(rid);
-      const subscribedQuality = qualities.find((q) => q.quality === quality);
-      if (!subscribedQuality) {
-        return;
-      }
-      if (encoding.active !== subscribedQuality.enabled) {
-        hasChanged = true;
-        encoding.active = subscribedQuality.enabled;
-        log.debug(`setting layer ${subscribedQuality.quality} to ${encoding.active ? 'enabled' : 'disabled'}`);
-
-        // FireFox does not support setting encoding.active to false, so we
-        // have a workaround of lowering its bitrate and resolution to the min.
-        if (isFireFox()) {
-          if (subscribedQuality.enabled) {
-            encoding.scaleResolutionDownBy = this.encodings![idx].scaleResolutionDownBy;
-            encoding.maxBitrate = this.encodings![idx].maxBitrate;
-            /* @ts-ignore */
-            encoding.maxFrameRate = this.encodings![idx].maxFrameRate;
-          } else {
-            encoding.scaleResolutionDownBy = 4;
-            encoding.maxBitrate = 10;
-            /* @ts-ignore */
-            encoding.maxFrameRate = 2;
-          }
-        }
-      }
-    });
-
-    if (hasChanged) {
-      params.encodings = encodings;
-      await this.sender.setParameters(params);
-    }
-  }
-
-  private monitorSender = async () => {
-    if (!this.sender) {
-      this._currentBitrate = 0;
-      return;
-    }
-
-    let stats: VideoSenderStats[] | undefined;
-    try {
-      stats = await this.getSenderStats();
-    } catch (e) {
-      log.error('could not get audio sender stats', e);
-      return;
-    }
-    const statsMap = new Map<string, VideoSenderStats>(stats.map((s) => [s.rid, s]));
-
-    if (this.prevStats) {
-      let totalBitrate = 0;
-      statsMap.forEach((s, key) => {
-        const prev = this.prevStats?.get(key);
-        totalBitrate += computeBitrate(s, prev);
-      });
-      this._currentBitrate = totalBitrate;
-    }
-
-    this.prevStats = statsMap;
-    setTimeout(() => {
-      this.monitorSender();
-    }, monitorFrequency);
-  };
-
-  protected async handleAppVisibilityChanged() {
-    await super.handleAppVisibilityChanged();
-    if (!isMobile()) return;
-    if (this.isInBackground && this.source === Track.Source.Camera) {
-      this.mediaStreamTrack.enabled = false;
-    }
-  }
-}
-
-export function videoQualityForRid(rid: string): VideoQuality {
-  switch (rid) {
-    case 'f':
-      return VideoQuality.HIGH;
-    case 'h':
-      return VideoQuality.MEDIUM;
-    case 'q':
-      return VideoQuality.LOW;
-    default:
-      return VideoQuality.UNRECOGNIZED;
-  }
-}
-
-export function videoLayersFromEncodings(
-  width: number,
-  height: number,
-  encodings?: RTCRtpEncodingParameters[],
-): VideoLayer[] {
-  // default to a single layer, HQ
-  if (!encodings) {
-    return [{
-      quality: VideoQuality.HIGH,
-      width,
-      height,
-      bitrate: 0,
-      ssrc: 0,
-    }];
-  }
-  return encodings.map((encoding) => {
-    const scale = encoding.scaleResolutionDownBy ?? 1;
-    let quality = videoQualityForRid(encoding.rid ?? '');
-    if (quality === VideoQuality.UNRECOGNIZED && encodings.length === 1) {
-      quality = VideoQuality.HIGH;
-    }
-    return {
-      quality,
-      width: width / scale,
-      height: height / scale,
-      bitrate: encoding.maxBitrate ?? 0,
-      ssrc: 0,
-    };
-  });
-}

package/src/room/track/RemoteAudioTrack.ts

@@ -1,58 +0,0 @@
-import { AudioReceiverStats, computeBitrate, monitorFrequency } from '../stats';
-import RemoteTrack from './RemoteTrack';
-import { Track } from './Track';
-
-export default class RemoteAudioTrack extends RemoteTrack {
-  private prevStats?: AudioReceiverStats;
-
-  constructor(
-    mediaTrack: MediaStreamTrack,
-    sid: string,
-    receiver?: RTCRtpReceiver,
-  ) {
-    super(mediaTrack, sid, Track.Kind.Audio, receiver);
-  }
-
-  protected monitorReceiver = async () => {
-    if (!this.receiver) {
-      this._currentBitrate = 0;
-      return;
-    }
-    const stats = await this.getReceiverStats();
-
-    if (stats && this.prevStats && this.receiver) {
-      this._currentBitrate = computeBitrate(stats, this.prevStats);
-    }
-
-    this.prevStats = stats;
-    setTimeout(() => {
-      this.monitorReceiver();
-    }, monitorFrequency);
-  };
-
-  protected async getReceiverStats(): Promise<AudioReceiverStats | undefined> {
-    if (!this.receiver) {
-      return;
-    }
-
-    const stats = await this.receiver.getStats();
-    let receiverStats: AudioReceiverStats | undefined;
-    stats.forEach((v) => {
-      if (v.type === 'inbound-rtp') {
-        receiverStats = {
-          type: 'audio',
-          timestamp: v.timestamp,
-          jitter: v.jitter,
-          bytesReceived: v.bytesReceived,
-          concealedSamples: v.concealedSamples,
-          concealmentEvents: v.concealmentEvents,
-          silentConcealedSamples: v.silentConcealedSamples,
-          silentConcealmentEvents: v.silentConcealmentEvents,
-          totalAudioEnergy: v.totalAudioEnergy,
-          totalSamplesDuration: v.totalSamplesDuration,
-        };
-      }
-    });
-    return receiverStats;
-  }
-}

package/src/room/track/RemoteTrack.ts

@@ -1,62 +0,0 @@
-import { TrackEvent } from '../events';
-import { monitorFrequency } from '../stats';
-import { Track } from './Track';
-
-export default abstract class RemoteTrack extends Track {
-  /** @internal */
-  receiver?: RTCRtpReceiver;
-
-  streamState: Track.StreamState = Track.StreamState.Active;
-
-  constructor(
-    mediaTrack: MediaStreamTrack,
-    sid: string,
-    kind: Track.Kind,
-    receiver?: RTCRtpReceiver,
-  ) {
-    super(mediaTrack, kind);
-    this.sid = sid;
-    this.receiver = receiver;
-  }
-
-  /** @internal */
-  setMuted(muted: boolean) {
-    if (this.isMuted !== muted) {
-      this.isMuted = muted;
-      this.emit(muted ? TrackEvent.Muted : TrackEvent.Unmuted, this);
-    }
-  }
-
-  /** @internal */
-  setMediaStream(stream: MediaStream) {
-    // this is needed to determine when the track is finished
-    // we send each track down in its own MediaStream, so we can assume the
-    // current track is the only one that can be removed.
-    this.mediaStream = stream;
-    stream.onremovetrack = () => {
-      this.receiver = undefined;
-      this._currentBitrate = 0;
-      this.emit(TrackEvent.Ended, this);
-    };
-  }
-
-  start() {
-    this.startMonitor();
-    // use `enabled` of track to enable re-use of transceiver
-    super.enable();
-  }
-
-  stop() {
-    // use `enabled` of track to enable re-use of transceiver
-    super.disable();
-  }
-
-  /* @internal */
-  startMonitor() {
-    setTimeout(() => {
-      this.monitorReceiver();
-    }, monitorFrequency);
-  }
-
-  protected abstract monitorReceiver(): void;
-}

package/src/room/track/RemoteTrackPublication.ts

@@ -1,198 +0,0 @@
-import log from '../../logger';
-import { TrackInfo, VideoQuality } from '../../proto/livekit_models';
-import {
-  UpdateSubscription,
-  UpdateTrackSettings,
-} from '../../proto/livekit_rtc';
-import { TrackEvent } from '../events';
-import RemoteVideoTrack from './RemoteVideoTrack';
-import { Track } from './Track';
-import { TrackPublication } from './TrackPublication';
-import { RemoteTrack } from './types';
-
-export default class RemoteTrackPublication extends TrackPublication {
-  track?: RemoteTrack;
-
-  /** @internal */
-  _allowed = true;
-
-  // keeps track of client's desire to subscribe to a track
-  protected subscribed?: boolean;
-
-  protected disabled: boolean = false;
-
-  protected currentVideoQuality?: VideoQuality = VideoQuality.HIGH;
-
-  protected videoDimensions?: Track.Dimensions;
-
-  /**
-   * Subscribe or unsubscribe to this remote track
-   * @param subscribed true to subscribe to a track, false to unsubscribe
-   */
-  setSubscribed(subscribed: boolean) {
-    this.subscribed = subscribed;
-
-    const sub: UpdateSubscription = {
-      trackSids: [this.trackSid],
-      subscribe: this.subscribed,
-      participantTracks: [{
-        // sending an empty participant id since TrackPublication doesn't keep it
-        // this is filled in by the participant that receives this message
-        participantSid: '',
-        trackSids: [this.trackSid],
-      }],
-    };
-    this.emit(TrackEvent.UpdateSubscription, sub);
-  }
-
-  get subscriptionStatus(): TrackPublication.SubscriptionStatus {
-    if (this.subscribed === false || !super.isSubscribed) {
-      return TrackPublication.SubscriptionStatus.Unsubscribed;
-    }
-    if (!this._allowed) {
-      return TrackPublication.SubscriptionStatus.NotAllowed;
-    }
-    return TrackPublication.SubscriptionStatus.Subscribed;
-  }
-
-  /**
-   * Returns true if track is subscribed, and ready for playback
-   */
-  get isSubscribed(): boolean {
-    if (this.subscribed === false) {
-      return false;
-    }
-    if (!this._allowed) {
-      return false;
-    }
-    return super.isSubscribed;
-  }
-
-  get isEnabled(): boolean {
-    return !this.disabled;
-  }
-
-  /**
-   * disable server from sending down data for this track. this is useful when
-   * the participant is off screen, you may disable streaming down their video
-   * to reduce bandwidth requirements
-   * @param enabled
-   */
-  setEnabled(enabled: boolean) {
-    if (!this.isManualOperationAllowed() || this.disabled === !enabled) {
-      return;
-    }
-    this.disabled = !enabled;
-
-    this.emitTrackUpdate();
-  }
-
-  /**
-   * for tracks that support simulcasting, adjust subscribed quality
-   *
-   * This indicates the highest quality the client can accept. if network
-   * bandwidth does not allow, server will automatically reduce quality to
-   * optimize for uninterrupted video
-   */
-  setVideoQuality(quality: VideoQuality) {
-    if (!this.isManualOperationAllowed() || this.currentVideoQuality === quality) {
-      return;
-    }
-    this.currentVideoQuality = quality;
-    this.videoDimensions = undefined;
-
-    this.emitTrackUpdate();
-  }
-
-  setVideoDimensions(dimensions: Track.Dimensions) {
-    if (!this.isManualOperationAllowed()) {
-      return;
-    }
-    if (this.videoDimensions?.width === dimensions.width
-        && this.videoDimensions?.height === dimensions.height) {
-      return;
-    }
-    if (this.track instanceof RemoteVideoTrack) { this.videoDimensions = dimensions; }
-    this.currentVideoQuality = undefined;
-
-    this.emitTrackUpdate();
-  }
-
-  get videoQuality(): VideoQuality | undefined {
-    return this.currentVideoQuality;
-  }
-
-  setTrack(track?: Track) {
-    if (this.track) {
-      // unregister listener
-      this.track.off(TrackEvent.VideoDimensionsChanged, this.handleVideoDimensionsChange);
-      this.track.off(TrackEvent.VisibilityChanged, this.handleVisibilityChange);
-      this.track.off(TrackEvent.Ended, this.handleEnded);
-    }
-    super.setTrack(track);
-    if (track) {
-      track.sid = this.trackSid;
-      track.on(TrackEvent.VideoDimensionsChanged, this.handleVideoDimensionsChange);
-      track.on(TrackEvent.VisibilityChanged, this.handleVisibilityChange);
-      track.on(TrackEvent.Ended, this.handleEnded);
-    }
-  }
-
-  /** @internal */
-  updateInfo(info: TrackInfo) {
-    super.updateInfo(info);
-    this.metadataMuted = info.muted;
-    this.track?.setMuted(info.muted);
-  }
-
-  private isManualOperationAllowed(): boolean {
-    if (this.isAdaptiveStream) {
-      log.warn('adaptive stream is enabled, cannot change track settings', this.trackSid);
-      return false;
-    }
-    if (!this.isSubscribed) {
-      log.warn('cannot update track settings when not subscribed', this.trackSid);
-      return false;
-    }
-    return true;
-  }
-
-  protected handleEnded = (track: RemoteTrack) => {
-    this.emit(TrackEvent.Ended, track);
-  };
-
-  protected get isAdaptiveStream(): boolean {
-    return this.track instanceof RemoteVideoTrack && this.track.isAdaptiveStream;
-  }
-
-  protected handleVisibilityChange = (visible: boolean) => {
-    log.debug('adaptivestream video visibility', this.trackSid, `visible=${visible}`);
-    this.disabled = !visible;
-    this.emitTrackUpdate();
-  };
-
-  protected handleVideoDimensionsChange = (dimensions: Track.Dimensions) => {
-    log.debug('adaptivestream video dimensions', this.trackSid, `${dimensions.width}x${dimensions.height}`);
-    this.videoDimensions = dimensions;
-    this.emitTrackUpdate();
-  };
-
-  /* @internal */
-  emitTrackUpdate() {
-    const settings: UpdateTrackSettings = UpdateTrackSettings.fromPartial({
-      trackSids: [this.trackSid],
-      disabled: this.disabled,
-    });
-    if (this.videoDimensions) {
-      settings.width = this.videoDimensions.width;
-      settings.height = this.videoDimensions.height;
-    } else if (this.currentVideoQuality !== undefined) {
-      settings.quality = this.currentVideoQuality;
-    } else {
-      // defaults to high quality
-      settings.quality = VideoQuality.HIGH;
-    }
-
-    this.emit(TrackEvent.UpdateSettings, settings);
-  }
-}