@webex/plugin-meetings 2.60.1-next.9 → 2.60.2

package/src/multistream/receiveSlot.ts

@@ -1,184 +0,0 @@
-/* eslint-disable valid-jsdoc */
-import {
-  MediaType,
-  ReceiveSlot as WcmeReceiveSlot,
-  ReceiveSlotEvents as WcmeReceiveSlotEvents,
-  StreamState,
-} from '@webex/internal-media-core';
-
-import LoggerProxy from '../common/logs/logger-proxy';
-import EventsScope from '../common/events/events-scope';
-
-export const ReceiveSlotEvents = {
-  SourceUpdate: 'sourceUpdate',
-  MaxFsUpdate: 'maxFsUpdate',
-};
-
-export type {StreamState} from '@webex/internal-media-core';
-export type CSI = number;
-export type MemberId = string;
-export type ReceiveSlotId = string;
-
-let receiveSlotCounter = 0;
-
-export type FindMemberIdCallback = (csi: CSI) => MemberId | undefined;
-
-/**
- * Class representing a receive slot. A single receive slot is able to receive a single track
- * for example some participant's main video or audio
- */
-export class ReceiveSlot extends EventsScope {
-  private readonly mcReceiveSlot: WcmeReceiveSlot;
-
-  private readonly findMemberIdCallback: FindMemberIdCallback;
-
-  public readonly id: ReceiveSlotId;
-
-  public readonly mediaType: MediaType;
-
-  #memberId?: MemberId;
-
-  #csi?: CSI;
-
-  #sourceState: StreamState;
-
-  /**
-   * constructor - don't use it directly, you should always use meeting.receiveSlotManager.allocateSlot()
-   * to create any receive slots
-   *
-   * @param {MediaType} mediaType
-   * @param {ReceiveSlot} mcReceiveSlot
-   * @param {FindMemberIdCallback} findMemberIdCallback callback for finding memberId for given CSI
-   */
-  constructor(
-    mediaType: MediaType,
-    mcReceiveSlot: WcmeReceiveSlot,
-    findMemberIdCallback: FindMemberIdCallback
-  ) {
-    super();
-
-    receiveSlotCounter += 1;
-
-    this.findMemberIdCallback = findMemberIdCallback;
-    this.mediaType = mediaType;
-    this.mcReceiveSlot = mcReceiveSlot;
-    this.#sourceState = 'no source';
-    this.id = `r${receiveSlotCounter}`;
-
-    this.setupEventListeners();
-  }
-
-  /**
-   * Getter for memberId
-   */
-  public get memberId() {
-    return this.#memberId;
-  }
-
-  /**
-   * Getter for csi
-   */
-  public get csi() {
-    return this.#csi;
-  }
-
-  /**
-   * Set the max frame size for this slot
-   * @param newFs frame size
-   */
-  public setMaxFs(newFs) {
-    // emit event for media request manager to listen to
-
-    this.emit(
-      {
-        file: 'meeting/receiveSlot',
-        function: 'findMemberId',
-      },
-      ReceiveSlotEvents.MaxFsUpdate,
-      {
-        maxFs: newFs,
-      }
-    );
-  }
-
-  /**
-   * Getter for sourceState
-   */
-  public get sourceState() {
-    return this.#sourceState;
-  }
-
-  /**
-   * registers event handlers with the underlying ReceiveSlot
-   */
-  private setupEventListeners() {
-    const scope = {
-      file: 'meeting/receiveSlot',
-      function: 'setupEventListeners',
-    };
-
-    this.mcReceiveSlot.on(
-      WcmeReceiveSlotEvents.SourceUpdate,
-      (state: StreamState, csi?: number) => {
-        LoggerProxy.logger.log(
-          `ReceiveSlot#setupEventListeners --> got source update on receive slot ${this.id}, mediaType=${this.mediaType}, csi=${csi}, state=${state}`
-        );
-        this.#memberId = csi ? this.findMemberIdCallback(csi) : undefined;
-        this.#csi = csi;
-        this.#sourceState = state;
-
-        this.emit(scope, ReceiveSlotEvents.SourceUpdate, {
-          state: this.#sourceState,
-          csi: this.#csi,
-          memberId: this.#memberId,
-        });
-      }
-    );
-  }
-
-  /** Tries to find the member id for this receive slot if it hasn't got one */
-  public findMemberId() {
-    if (this.#memberId === undefined && this.#csi) {
-      this.#memberId = this.findMemberIdCallback(this.#csi);
-
-      if (this.#memberId) {
-        // if we found the memberId, simulate source update so that the client app knows that something's changed
-        this.emit(
-          {
-            file: 'meeting/receiveSlot',
-            function: 'findMemberId',
-          },
-          ReceiveSlotEvents.SourceUpdate,
-          {
-            state: this.#sourceState,
-            csi: this.#csi,
-            memberId: this.#memberId,
-          }
-        );
-      }
-    }
-  }
-
-  /**
-   * @returns {string} a log message used to identify the receive slot
-   */
-  public get logString() {
-    return `ReceiveSlot - ${this.id}: ${JSON.stringify(this.mcReceiveSlot.id)}`;
-  }
-
-  /**
-   * The MediaStream object associated with this slot.
-   *
-   * @returns {MediaStream} The MediaStreamTrack.
-   */
-  get stream(): MediaStream {
-    return this.mcReceiveSlot.stream;
-  }
-
-  /**
-   * The underlying WCME receive slot
-   */
-  get wcmeReceiveSlot(): WcmeReceiveSlot {
-    return this.mcReceiveSlot;
-  }
-}

package/src/multistream/receiveSlotManager.ts

@@ -1,166 +0,0 @@
-/* eslint-disable valid-jsdoc */
-/* eslint-disable import/prefer-default-export */
-import {MediaType, ReceiveSlot as WcmeReceiveSlot} from '@webex/internal-media-core';
-import LoggerProxy from '../common/logs/logger-proxy';
-
-import {FindMemberIdCallback, ReceiveSlot} from './receiveSlot';
-
-export type CreateSlotCallback = (mediaType: MediaType) => Promise<WcmeReceiveSlot>;
-
-export type {CSI, FindMemberIdCallback} from './receiveSlot';
-
-/**
- * Manages all receive slots used by a meeting. WMCE receive slots cannot be ever deleted,
- * so this manager has a pool in order to re-use the slots that were released earlier.
- */
-export class ReceiveSlotManager {
-  private allocatedSlots: {[key in MediaType]: ReceiveSlot[]};
-
-  private freeSlots: {[key in MediaType]: ReceiveSlot[]};
-
-  private createSlotCallback: CreateSlotCallback;
-
-  private findMemberIdByCsiCallback: FindMemberIdCallback;
-
-  /**
-   * Constructor
-   * @param {Meeting} meeting
-   */
-  constructor(
-    createSlotCallback: CreateSlotCallback,
-    findMemberIdByCsiCallback: FindMemberIdCallback
-  ) {
-    this.allocatedSlots = {
-      [MediaType.AudioMain]: [],
-      [MediaType.VideoMain]: [],
-      [MediaType.AudioSlides]: [],
-      [MediaType.VideoSlides]: [],
-    };
-    this.freeSlots = {
-      [MediaType.AudioMain]: [],
-      [MediaType.VideoMain]: [],
-      [MediaType.AudioSlides]: [],
-      [MediaType.VideoSlides]: [],
-    };
-    this.createSlotCallback = createSlotCallback;
-    this.findMemberIdByCsiCallback = findMemberIdByCsiCallback;
-  }
-
-  /**
-   * Creates a new receive slot or returns one from the existing pool of free slots
-   *
-   * @param {MediaType} mediaType
-   * @returns {Promise<ReceiveSlot>}
-   */
-  async allocateSlot(mediaType: MediaType): Promise<ReceiveSlot> {
-    // try to use one of the free ones
-    const availableSlot = this.freeSlots[mediaType].pop();
-
-    if (availableSlot) {
-      this.allocatedSlots[mediaType].push(availableSlot);
-
-      LoggerProxy.logger.log(`${mediaType}: receive slot re-used: ${availableSlot.id}`);
-
-      return availableSlot;
-    }
-
-    // we have to create a new one
-    const wcmeReceiveSlot = await this.createSlotCallback(mediaType);
-
-    const receiveSlot = new ReceiveSlot(mediaType, wcmeReceiveSlot, this.findMemberIdByCsiCallback);
-
-    this.allocatedSlots[mediaType].push(receiveSlot);
-    LoggerProxy.logger.log(`${mediaType}: new receive slot allocated: ${receiveSlot.id}`);
-
-    return receiveSlot;
-  }
-
-  /**
-   * Releases the slot back to the pool so it can be re-used by others in the future
-   * @param {ReceiveSlot} slot
-   */
-  releaseSlot(slot: ReceiveSlot) {
-    const idx = this.allocatedSlots[slot.mediaType].findIndex(
-      (allocatedSlot) => allocatedSlot === slot
-    );
-
-    if (idx >= 0) {
-      this.allocatedSlots[slot.mediaType].splice(idx, 1);
-      this.freeSlots[slot.mediaType].push(slot);
-      LoggerProxy.logger.log(`${slot.mediaType}: receive slot released: ${slot.id}`);
-    } else {
-      LoggerProxy.logger.warn(
-        `ReceiveSlotManager#releaseSlot --> trying to release a ${slot.mediaType}} slot that is not managed by this ReceiveSlotManager`
-      );
-    }
-  }
-
-  /**
-   * Resets the slot manager - this method should be called when the media connection is torn down
-   */
-  reset() {
-    this.allocatedSlots = {
-      [MediaType.AudioMain]: [],
-      [MediaType.VideoMain]: [],
-      [MediaType.AudioSlides]: [],
-      [MediaType.VideoSlides]: [],
-    };
-    this.freeSlots = {
-      [MediaType.AudioMain]: [],
-      [MediaType.VideoMain]: [],
-      [MediaType.AudioSlides]: [],
-      [MediaType.VideoSlides]: [],
-    };
-  }
-
-  /**
-   * Returns statistics about the managed slots
-   *
-   * @returns {Object}
-   */
-  getStats() {
-    const numAllocatedSlots = {};
-    const numFreeSlots = {};
-
-    Object.keys(this.allocatedSlots).forEach((key) => {
-      if (this.allocatedSlots[key].length > 0) {
-        numAllocatedSlots[key] = this.allocatedSlots[key].length;
-      }
-    });
-
-    Object.keys(this.freeSlots).forEach((key) => {
-      if (this.freeSlots[key].length > 0) {
-        numFreeSlots[key] = this.freeSlots[key].length;
-      }
-    });
-
-    return {
-      numAllocatedSlots,
-      numFreeSlots,
-    };
-  }
-
-  /**
-   * Tries to find the member id on all allocated receive slots
-   * This function should be called when new members are added to the meeting.
-   */
-  updateMemberIds() {
-    Object.keys(this.allocatedSlots).forEach((key) => {
-      this.allocatedSlots[key].forEach((slot: ReceiveSlot) => {
-        slot.findMemberId();
-      });
-    });
-  }
-
-  /**
-   * Find a receive slot by a ssrc.
-   *
-   * @param ssrc - The ssrc of the receive slot to find.
-   * @returns - The receive slot with this ssrc, undefined if not found.
-   */
-  findReceiveSlotBySsrc(ssrc: number): ReceiveSlot | undefined {
-    return Object.values(this.allocatedSlots)
-      .flat()
-      .find((r) => ssrc && r.wcmeReceiveSlot?.id?.ssrc === ssrc);
-  }
-}

package/src/multistream/remoteMedia.ts

@@ -1,254 +0,0 @@
-/* eslint-disable valid-jsdoc */
-import {MediaType, StreamState} from '@webex/internal-media-core';
-import LoggerProxy from '../common/logs/logger-proxy';
-import EventsScope from '../common/events/events-scope';
-
-import {MediaRequestId, MediaRequestManager} from './mediaRequestManager';
-import {CSI, ReceiveSlot, ReceiveSlotEvents} from './receiveSlot';
-
-export const RemoteMediaEvents = {
-  SourceUpdate: ReceiveSlotEvents.SourceUpdate,
-  Stopped: 'stopped',
-};
-
-export type RemoteVideoResolution =
-  | 'thumbnail' // the smallest possible resolution, 90p or less
-  | 'very small' // 180p or less
-  | 'small' // 360p or less
-  | 'medium' // 720p or less
-  | 'large' // 1080p or less
-  | 'best'; // highest possible resolution
-
-/**
- * Converts pane size into h264 maxFs
- * @param {PaneSize} paneSize
- * @returns {number}
- */
-export function getMaxFs(paneSize: RemoteVideoResolution): number {
-  let maxFs;
-
-  switch (paneSize) {
-    case 'thumbnail':
-      maxFs = 60;
-      break;
-    case 'very small':
-      maxFs = 240;
-      break;
-    case 'small':
-      maxFs = 920;
-      break;
-    case 'medium':
-      maxFs = 3600;
-      break;
-    case 'large':
-      maxFs = 8192;
-      break;
-    case 'best':
-      maxFs = 8192; // for now 'best' is 1080p, so same as 'large'
-      break;
-    default:
-      LoggerProxy.logger.warn(
-        `RemoteMedia#getMaxFs --> unsupported paneSize: ${paneSize}, using "medium" instead`
-      );
-      maxFs = 3600;
-  }
-
-  return maxFs;
-}
-
-type Options = {
-  resolution?: RemoteVideoResolution; // applies only to groups of type MediaType.VideoMain and MediaType.VideoSlides
-};
-
-export type RemoteMediaId = string;
-
-let remoteMediaCounter = 0;
-
-/**
- * Class representing a remote audio/video stream.
- *
- * Internally it is associated with a specific receive slot
- * and a media request for it.
- */
-export class RemoteMedia extends EventsScope {
-  private receiveSlot?: ReceiveSlot;
-
-  private readonly mediaRequestManager: MediaRequestManager;
-
-  private readonly options: Options;
-
-  private mediaRequestId?: MediaRequestId;
-
-  public readonly id: RemoteMediaId;
-
-  /**
-   * Constructs RemoteMedia instance
-   *
-   * @param receiveSlot
-   * @param mediaRequestManager
-   * @param options
-   */
-  constructor(
-    receiveSlot: ReceiveSlot,
-    mediaRequestManager: MediaRequestManager,
-    options?: Options
-  ) {
-    super();
-    remoteMediaCounter += 1;
-    this.receiveSlot = receiveSlot;
-    this.mediaRequestManager = mediaRequestManager;
-    this.options = options || {};
-    this.setupEventListeners();
-    this.id = `RM${remoteMediaCounter}-${this.receiveSlot.id}`;
-  }
-
-  /**
-   * Supply the width and height of the video element
-   * to restrict the requested resolution to this size
-   * @param width width of the video element
-   * @param height height of the video element
-   */
-  public setSizeHint(width, height) {
-    // only base on height for now
-    let fs: number;
-
-    if (height < 135) {
-      fs = 60;
-    } else if (height < 270) {
-      fs = 240;
-    } else if (height < 540) {
-      fs = 920;
-    } else if (height <= 720) {
-      fs = 3600;
-    } else {
-      fs = 8192;
-    }
-
-    this.receiveSlot?.setMaxFs(fs);
-  }
-
-  /**
-   * Invalidates the remote media by clearing the reference to a receive slot and
-   * cancelling the media request.
-   * After this call the remote media is unusable.
-   *
-   * @param {boolean} commit - whether to commit the cancellation of the media request
-   * @internal
-   */
-  public stop(commit = true) {
-    this.cancelMediaRequest(commit);
-    this.receiveSlot?.removeAllListeners();
-    this.receiveSlot = undefined;
-    this.emit(
-      {
-        file: 'multistream/remoteMedia',
-        function: 'stop',
-      },
-      RemoteMediaEvents.Stopped,
-      {}
-    );
-  }
-
-  /**
-   * Sends a new media request. This method can only be used for receiver-selected policy,
-   * because only in that policy we have a 1-1 relationship between RemoteMedia and MediaRequest
-   * and the request id is then stored in this RemoteMedia instance.
-   * For active-speaker policy, the same request is shared among many RemoteMedia instances,
-   * so it's managed through RemoteMediaGroup
-   *
-   * @internal
-   */
-  public sendMediaRequest(csi: CSI, commit: boolean) {
-    if (this.mediaRequestId) {
-      this.cancelMediaRequest(false);
-    }
-
-    if (!this.receiveSlot) {
-      throw new Error('sendMediaRequest() called on an invalidated RemoteMedia instance');
-    }
-
-    this.mediaRequestId = this.mediaRequestManager.addRequest(
-      {
-        policyInfo: {
-          policy: 'receiver-selected',
-          csi,
-        },
-        receiveSlots: [this.receiveSlot],
-        codecInfo: this.options.resolution && {
-          codec: 'h264',
-          maxFs: getMaxFs(this.options.resolution),
-        },
-      },
-      commit
-    );
-  }
-
-  /**
-   * @internal
-   */
-  public cancelMediaRequest(commit: boolean) {
-    if (this.mediaRequestId) {
-      this.mediaRequestManager.cancelRequest(this.mediaRequestId, commit);
-      this.mediaRequestId = undefined;
-    }
-  }
-
-  /**
-   * registers event listeners on the receive slot and forwards all the events
-   */
-  private setupEventListeners() {
-    if (this.receiveSlot) {
-      const scope = {
-        file: 'multistream/remoteMedia',
-        function: 'setupEventListeners',
-      };
-
-      this.receiveSlot.on(ReceiveSlotEvents.SourceUpdate, (data) => {
-        this.emit(scope, RemoteMediaEvents.SourceUpdate, data);
-      });
-    }
-  }
-
-  /**
-   * Getter for mediaType
-   */
-  public get mediaType(): MediaType {
-    return this.receiveSlot?.mediaType;
-  }
-
-  /**
-   * Getter for memberId
-   */
-  public get memberId() {
-    return this.receiveSlot?.memberId;
-  }
-
-  /**
-   * Getter for csi
-   */
-  public get csi() {
-    return this.receiveSlot?.csi;
-  }
-
-  /**
-   * Getter for source state
-   */
-  public get sourceState(): StreamState {
-    return this.receiveSlot?.sourceState;
-  }
-
-  /**
-   * Getter for remote media stream
-   */
-  public get stream() {
-    return this.receiveSlot?.stream;
-  }
-
-  /**
-   * @internal
-   * @returns {ReceiveSlot}
-   */
-  public getUnderlyingReceiveSlot() {
-    return this.receiveSlot;
-  }
-}