@livedigital/client 3.48.0 → 3.49.1

package/src/engine/media/tracks/DefaultBaseTrack.ts

@@ -1,592 +0,0 @@
-import type { types } from 'mediasoup-client';
-import { serializeError } from 'serialize-error';
-import type { ParsedOutboundAudioStreamStats, ParsedOutboundVideoStreamStats } from 'webrtc-issue-detector';
-import type Media from '..';
-import { INTERNAL_CLIENT_EVENTS } from '../../../constants/events';
-import EnhancedEventEmitter from '../../../EnhancedEventEmitter';
-import OperationError from '../../../errors/OperationError';
-import filterStatsCodecs from '../../../helpers/filterStatsCodecs';
-import { isVp9 } from '../../../helpers/media';
-import {
-  type BaseTrackInfo,
-  type EncoderConfig,
-  type PrepareProducerEncodingsParams,
-  TrackLabel,
-  type TrackOutboundStats,
-  type TrackProduceParams,
-} from '../../../types/common';
-import type { InternalObserverEvents } from '../../../types/engine';
-import type {
-  BaseTrack, BaseTrackDependenciesParams, BaseTrackParams, ProducerAppData,
-} from '../../../types/media';
-import type Logger from '../../Logger';
-import type { MyPeer } from '../../MyPeer';
-import type Network from '../../network';
-import OutboundTrackStatsManager from '../../WebRTCStats/OutboudTrackStatsManager';
-import type StatsHandler from '../../WebRTCStats/StatsHandler';
-import type MediaStreamTrackManager from './MediaStreamTrackManager';
-import type LocalMutex from '../../LocalMutex';
-import { MutexKey } from '../../../constants/mutex';
-import type ProducerCloseManager from '../producer/ProducerCloseManager';
-
-type BaseTrackConstructorParams = BaseTrackParams & BaseTrackDependenciesParams;
-
-export interface LoggerContext {
-  label: TrackLabel;
-  id: string;
-  kind: types.MediaKind;
-  producerId: string | undefined;
-  paused: boolean;
-  published: boolean;
-}
-
-const STATS_MAX_ATTEMPTS = 5;
-const STATS_ATTEMPT_DELAY = 150;
-
-class DefaultBaseTrack implements BaseTrack {
-  #mediaStreamTrack: MediaStreamTrack;
-
-  #originalTrack?: MediaStreamTrack;
-
-  protected encoderConfig: EncoderConfig = {};
-
-  private producer?: types.Producer<ProducerAppData>;
-
-  private label: TrackLabel = TrackLabel.Unknown;
-
-  readonly #myPeer: MyPeer;
-
-  readonly #media: Media;
-
-  readonly #network: Network;
-
-  readonly #producerCloseManager: ProducerCloseManager;
-
-  readonly logger: Logger;
-
-  readonly #internalEventEmitter: EnhancedEventEmitter<InternalObserverEvents>;
-
-  readonly #constraints: MediaStreamConstraints;
-
-  readonly #mediaStreamTrackManager: MediaStreamTrackManager;
-
-  readonly #eventEmitter: EnhancedEventEmitter;
-
-  #stopTrackOnPause = true;
-
-  readonly #mutex: LocalMutex;
-
-  #webrtcStatsManager: OutboundTrackStatsManager;
-
-  readonly #statsHandler: StatsHandler;
-
-  constructor(params: BaseTrackConstructorParams) {
-    const {
-      mediaStreamTrack,
-      internalEventEmitter,
-      constraints,
-      mediaStreamTrackManager,
-      media,
-      myPeer,
-      network,
-      producerCloseManager,
-      mutex,
-      loggerFactory,
-      loggerNamespace,
-      statsHandler,
-    } = params;
-    this.#mediaStreamTrack = mediaStreamTrack;
-    this.#internalEventEmitter = internalEventEmitter;
-    this.#constraints = constraints;
-    this.#mediaStreamTrackManager = mediaStreamTrackManager;
-    this.#eventEmitter = new EnhancedEventEmitter();
-    this.logger = loggerFactory(loggerNamespace);
-    this.#mutex = mutex;
-    this.#media = media;
-    this.#myPeer = myPeer;
-    this.#network = network;
-    this.#producerCloseManager = producerCloseManager;
-    this.#statsHandler = statsHandler;
-    this.#webrtcStatsManager = new OutboundTrackStatsManager({
-      track: mediaStreamTrack,
-      statsHandler,
-    });
-  }
-
-  get videoWebRTCStats(): ParsedOutboundVideoStreamStats | undefined {
-    return this.#webrtcStatsManager.videoWebRTCStats;
-  }
-
-  get audioWebRTCStats(): ParsedOutboundAudioStreamStats | undefined {
-    return this.#webrtcStatsManager.audioWebRTCStats;
-  }
-
-  get logCtx(): LoggerContext {
-    return {
-      label: this.getLabel(),
-      id: this.id,
-      kind: this.kind,
-      producerId: this.producerId,
-      paused: this.isPaused,
-      published: this.isPublished,
-    };
-  }
-
-  get observer(): EnhancedEventEmitter {
-    return this.#eventEmitter;
-  }
-
-  get mediaStreamTrack(): MediaStreamTrack {
-    return this.#mediaStreamTrack;
-  }
-
-  get originalTrack(): MediaStreamTrack | undefined {
-    return this.#originalTrack;
-  }
-
-  get id(): string {
-    return this.mediaStreamTrack.id;
-  }
-
-  get kind(): types.MediaKind {
-    return this.mediaStreamTrack.kind as types.MediaKind;
-  }
-
-  get producerId(): string | undefined {
-    return this.producer?.id;
-  }
-
-  get isPublished(): boolean {
-    return this.producer
-      ? !this.producer.closed
-      : false;
-  }
-
-  get isPaused(): boolean {
-    return this.producer?.paused ?? false;
-  }
-
-  get internalEventEmitter(): EnhancedEventEmitter<InternalObserverEvents> {
-    return this.#internalEventEmitter;
-  }
-
-  getLabel(): TrackLabel {
-    return this.label;
-  }
-
-  setLabel(label: TrackLabel): void {
-    this.label = label;
-  }
-
-  setEncoderConfig(encoderConfig: EncoderConfig): void {
-    this.encoderConfig = encoderConfig;
-  }
-
-  getEncoderConfig(): EncoderConfig {
-    return this.encoderConfig;
-  }
-
-  setProducer(producer: types.Producer): void {
-    this.producer = producer as types.Producer<ProducerAppData>;
-  }
-
-  setStopTrackOnPause(value: boolean): void {
-    if (this.isPublished) {
-      return;
-    }
-
-    this.#stopTrackOnPause = value;
-  }
-
-  getProducer(): types.Producer | undefined {
-    return this.producer;
-  }
-
-  protected setOriginalTrack(): void {
-    this.#originalTrack = this.mediaStreamTrack;
-  }
-
-  async closeProducer(stopTrack = true): Promise<void> {
-    const release = await this.#mutex.lock(MutexKey.CloseProducer);
-
-    if (!this.producer) {
-      release();
-
-      return;
-    }
-
-    const { producerId } = this;
-
-    if (producerId) {
-      await this.#producerCloseManager.close(this.getLabel(), producerId);
-    }
-
-    this.producer.close();
-    this.producer = undefined;
-
-    if (stopTrack) {
-      this.stopMediaStreamTrack();
-    }
-
-    release();
-  }
-
-  async setPriority(priority: RTCPriorityType): Promise<void> {
-    if (!this.producer) {
-      this.logger.warn('setPriority()', {
-        priority,
-        reason: 'Not published yet',
-      });
-
-      return;
-    }
-
-    await this.producer.setRtpEncodingParameters({ priority });
-    this.logger.debug('setPriority()', {
-      label: this.getLabel(),
-      priority,
-    });
-  }
-
-  stopMediaStreamTrack(): void {
-    this.mediaStreamTrack.stop();
-    this.mediaStreamTrack.dispatchEvent(new Event('ended'));
-    this.stopOriginalTrack();
-  }
-
-  protected stopOriginalTrack(): void {
-    if (this.#originalTrack) {
-      this.#originalTrack.stop();
-      this.#originalTrack = undefined;
-    }
-  }
-
-  async produce({
-    encodings,
-    codecOptions,
-    preferredCodec,
-    transformParams,
-    keyFrameRequestDelay,
-  }: TrackProduceParams): Promise<void> {
-    if (!this.#myPeer.canPublish) {
-      this.logger.error('produce()', { message: 'Not enough access to produce' });
-      throw new OperationError('not_enough_access', new Error('Not enough access to produce'));
-    }
-
-    if (this.producer) {
-      throw new OperationError('track_already_produced', new Error('Track already produced'));
-    }
-
-    try {
-      await this.#producerCloseManager.ensureNoPending(this.getLabel());
-
-      // if you perform transport.produce while you switching to VPN,
-      // it will cause an irreversible failure in the formation m-section of the SDP. Mediasoup bug?
-      // TODO: find a solution to the problem
-      await this.#network.ping();
-
-      const { rtpCapabilities: { codecs } } = this.#media.mediasoupDevice;
-      const codec = codecs?.find((c) => c.mimeType.toLowerCase() === `${ this.kind }/${ preferredCodec }`);
-      const maxSpatialLayer = 0;
-      // We start with max layer if possible and then reduce to proper layer (to have ability to calc max layer)
-      const preparedEncodings = this.prepareProducerEncodings({
-        codec,
-        encodings: encodings ?? [],
-        maxSpatialLayer: (encodings ?? []).length - 1,
-      });
-      const appData: ProducerAppData = {
-        trackTransformParams: transformParams,
-        peerId: String(this.#myPeer.id),
-        label: this.getLabel(),
-        maxSpatialLayer,
-        encodings: preparedEncodings,
-        codecOptions,
-        preferredCodec,
-        codec,
-        keyFrameRequestDelay,
-      };
-
-      const producer = await this.#network.sendTransport?.produce<ProducerAppData>({
-        track: this.mediaStreamTrack,
-        encodings: preparedEncodings,
-        codecOptions,
-        codec,
-        stopTracks: false,
-        disableTrackOnPause: true,
-        zeroRtpOnPause: true,
-        appData,
-      });
-
-      if (!producer) {
-        return;
-      }
-
-      const sender = producer.rtpSender;
-      const isSafari = (): boolean => /Safari/i.test(navigator.userAgent);
-
-      if (encodings && sender && isSafari()) {
-        const params = sender.getParameters();
-        encodings.forEach(({ maxBitrate, scaleResolutionDownBy }, index) => {
-          if (params.encodings[index]) {
-            params.encodings[index].maxBitrate = maxBitrate;
-            params.encodings[index].scaleResolutionDownBy = scaleResolutionDownBy;
-          }
-        });
-
-        await sender.setParameters(params);
-      }
-
-      this.setProducer(producer);
-
-      if ((this.producer as unknown as types.Producer<ProducerAppData>)?.track?.id !== this.#mediaStreamTrack.id) {
-        this.logger.info('Producer initialized with old track, updating', {
-          oldTrackId: (this.producer as unknown as types.Producer<ProducerAppData>)?.track?.id,
-          newTrackId: this.#mediaStreamTrack.id,
-        });
-
-        await this.replaceTrack(this.#mediaStreamTrack);
-      }
-
-      if (this.kind === 'video') {
-        if (encodings && sender && codec && isVp9(codec.mimeType) && !isSafari()) {
-          await sender.setParameters({
-            ...sender.getParameters(),
-            encodings: this.prepareProducerEncodings({ encodings, codec, maxSpatialLayer }),
-          });
-        } else {
-          await producer.setMaxSpatialLayer(maxSpatialLayer);
-        }
-
-        await this.#network.setProducerMaxSpatialLayer(producer.id, maxSpatialLayer);
-      }
-
-      if (this.kind === 'audio') {
-        await this.setPriority('high');
-      }
-
-      this.logger.debug('produce()', { track: this.logCtx, encodings, codecOptions });
-    } catch (error) {
-      this.logger.error('produce()', { error, track: this.logCtx });
-      throw new OperationError('track_publish_failed', error);
-    }
-  }
-
-  async publish(): Promise<void> {
-    await this.produce({});
-    this.internalEventEmitter.emit(INTERNAL_CLIENT_EVENTS.trackProduced, this);
-  }
-
-  async unpublish(stopTrack = true): Promise<void> {
-    try {
-      if (stopTrack) {
-        this.stopMediaStreamTrack();
-      }
-
-      this.internalEventEmitter.emit(INTERNAL_CLIENT_EVENTS.trackUnproduced, this);
-
-      if (this.producer) {
-        await this.closeProducer();
-      }
-
-      this.logger.debug('unpublish()', { track: this.logCtx });
-    } catch (error) {
-      this.logger.error('unpublish()', { error });
-    }
-  }
-
-  private async pauseRemoteProducer(producerId: string): Promise<void> {
-    await this.#network.pauseRemoteProducer(producerId);
-  }
-
-  private async resumeRemoteProducer(producerId: string): Promise<void> {
-    await this.#network.resumeRemoteProducer(producerId);
-  }
-
-  protected async mute(stopTrackOnPauseCallback?: () => void): Promise<void> {
-    const release = await this.#mutex.lock(MutexKey.Mute);
-
-    if (!this.producer) {
-      this.logger.warn('pause()', { message: 'Track is not published', track: this.logCtx });
-      release();
-
-      return;
-    }
-
-    try {
-      this.producer.pause();
-      this.logger.debug('pause()', { track: this.logCtx });
-
-      if (this.#stopTrackOnPause) {
-        stopTrackOnPauseCallback?.();
-        this.#mediaStreamTrack.stop();
-        this.stopOriginalTrack();
-        this.internalEventEmitter.emit(INTERNAL_CLIENT_EVENTS.trackClosed, this);
-        await this.pauseRemoteProducer(this.producer.id);
-
-        return;
-      }
-
-      await this.pauseRemoteProducer(this.producer.id);
-      this.internalEventEmitter.emit(INTERNAL_CLIENT_EVENTS.trackPaused, this);
-    } catch (error) {
-      this.logger.error('pause()', { error, track: this.logCtx });
-      await this.#media.deleteTrack(this);
-      this.internalEventEmitter.emit(INTERNAL_CLIENT_EVENTS.trackFailed, this);
-      throw new OperationError('track_pause_failed', error);
-    } finally {
-      release();
-    }
-  }
-
-  public async resume(): Promise<void> {
-    const release = await this.#mutex.lock(MutexKey.Resume);
-
-    if (!this.producer) {
-      this.logger.warn('resume()', { message: 'Track is not published', track: this.logCtx });
-      release();
-
-      return;
-    }
-
-    try {
-      this.logger.debug('resume()', { track: this.logCtx });
-
-      if (this.#stopTrackOnPause) {
-        await this.reopenMediaStreamTrack();
-        await this.resumeProducer();
-        this.internalEventEmitter.emit(INTERNAL_CLIENT_EVENTS.trackReopened, this);
-
-        return;
-      }
-
-      await this.resumeProducer();
-      this.internalEventEmitter.emit(INTERNAL_CLIENT_EVENTS.trackResumed, this);
-    } catch (error) {
-      this.logger.error('resume()', { error, track: this.logCtx });
-      throw new OperationError('track_resume_failed', error);
-    } finally {
-      release();
-    }
-  }
-
-  async getInfo(): Promise<BaseTrackInfo> {
-    const {
-      width, height, frameRate, aspectRatio,
-    } = this.#mediaStreamTrack.getSettings();
-
-    return {
-      trackId: this.#mediaStreamTrack.id,
-      readyState: this.#mediaStreamTrack.readyState,
-      kind: this.kind,
-      label: this.label,
-      width,
-      height,
-      frameRate,
-      aspectRatio,
-      paused: this.isPaused,
-      trackOutboundStats: await this.getStats(),
-    };
-  }
-
-  async getStats(): Promise<TrackOutboundStats | undefined> {
-    try {
-      return {
-        producerId: this.producer?.id,
-        codec: this.producer?.rtpParameters.codecs.find((codec) => filterStatsCodecs(codec)),
-        dtlsState: this.producer?.rtpSender?.transport?.state,
-        rtcStats: await this.getOutboundRTPStreamStats(),
-      };
-    } catch (error) {
-      this.logger.debug('getStats()', { error });
-
-      return undefined;
-    }
-  }
-
-  async replaceTrack(track: MediaStreamTrack): Promise<void> {
-    try {
-      this.#mediaStreamTrack = track;
-      this.internalEventEmitter.emit(INTERNAL_CLIENT_EVENTS.trackReopened, this);
-      this.observer.safeEmit('track-changed', { track });
-      await this.producer?.replaceTrack({ track });
-      this.#webrtcStatsManager = new OutboundTrackStatsManager({
-        track,
-        statsHandler: this.#statsHandler,
-      });
-    } catch (error) {
-      this.logger.warn('replaceTrack()', { error });
-    }
-  }
-
-  private async resumeProducer(): Promise<void> {
-    if (!this.producer) {
-      this.logger.debug('resumeProducer()', { message: 'Track not produced yet', track: this.logCtx });
-
-      return;
-    }
-
-    await this.resumeRemoteProducer(this.producer.id);
-    this.producer.resume();
-  }
-
-  private async reopenMediaStreamTrack(): Promise<void> {
-    const track = await this.#mediaStreamTrackManager.createMediaStreamTrack({
-      label: this.label,
-      constraints: this.#constraints,
-    });
-
-    this.#mediaStreamTrack = track;
-    await this.producer?.replaceTrack({ track });
-  }
-
-  private prepareProducerEncodings(
-    params: PrepareProducerEncodingsParams,
-  ): RTCRtpEncodingParameters[] {
-    const { encodings, codec, maxSpatialLayer } = params;
-
-    // for VP9 can use only one item in encodings array
-    return encodings && encodings.length > 1 && codec && isVp9(codec.mimeType)
-      ? [encodings[maxSpatialLayer] || encodings[0]]
-      : encodings;
-  }
-
-  private async getOutboundRTPStreamStats(): Promise<RTCOutboundRtpStreamStats> {
-    return await new Promise((resolve, reject) => {
-      const getRTCStatsReport = async (attempt = 0): Promise<void> => {
-        if (!this.producer) {
-          throw new Error('Producer is missed');
-        }
-
-        try {
-          const rtcStatsReport = await this.producer.getStats();
-          const outboundRTPStreamStats: RTCOutboundRtpStreamStats = Array.from(rtcStatsReport.values())
-            .find((stat) => stat.type === 'outbound-rtp');
-
-          if (!outboundRTPStreamStats && attempt < STATS_MAX_ATTEMPTS) {
-            setTimeout(async () => await getRTCStatsReport(attempt + 1), STATS_ATTEMPT_DELAY);
-
-            return;
-          }
-
-          if (attempt >= STATS_MAX_ATTEMPTS && !outboundRTPStreamStats) {
-            reject(new Error('OutboundRTPStreamStat not exist'));
-          }
-
-          resolve(outboundRTPStreamStats);
-        } catch (error) {
-          reject(new Error('Can not get RTCStatsReport'));
-          this.logger.debug('getOutboundRTPStreamStats()', { error });
-        }
-      };
-
-      getRTCStatsReport().catch((error: unknown) => {
-        this.logger.debug('Error executing getRTCStatsReport', {
-          case: 'DefaultBaseTrack',
-          error: serializeError(error),
-        });
-      });
-    });
-  }
-}
-
-export default DefaultBaseTrack;