@webex/plugin-meetings 3.0.0-beta.14 → 3.0.0-beta.141

package/src/multistream/mediaRequestManager.ts

@@ -1,9 +1,20 @@
 /* eslint-disable require-jsdoc */
-import {MediaConnection as MC} from '@webex/internal-media-core';
+import {
+  StreamRequest,
+  Policy,
+  ActiveSpeakerInfo,
+  ReceiverSelectedInfo,
+  CodecInfo as WcmeCodecInfo,
+  H264Codec,
+  getRecommendedMaxBitrateForFrameSize,
+  RecommendedOpusBitrates,
+} from '@webex/internal-media-core';
+import {cloneDeep, debounce, isEmpty} from 'lodash';
 
 import LoggerProxy from '../common/logs/logger-proxy';
 
-import {ReceiveSlot, ReceiveSlotId} from './receiveSlot';
+import {ReceiveSlot, ReceiveSlotEvents} from './receiveSlot';
+import {getMaxFs} from './remoteMedia';
 
 export interface ActiveSpeakerPolicyInfo {
   policy: 'active-speaker';
@@ -35,6 +46,8 @@ export interface MediaRequest {
   policyInfo: PolicyInfo;
   receiveSlots: Array<ReceiveSlot>;
   codecInfo?: CodecInfo;
+  preferredMaxFs?: number;
+  handleMaxFs?: ({maxFs}: {maxFs: number}) => void;
 }
 
 export type MediaRequestId = string;
@@ -47,79 +60,206 @@ const CODEC_DEFAULTS = {
   },
 };
 
-type SendMediaRequestsCallback = (mediaRequests: MC.MediaRequest[]) => void;
+const DEBOUNCED_SOURCE_UPDATE_TIME = 1000;
 
+type DegradationPreferences = {
+  maxMacroblocksLimit: number;
+};
+
+type SendMediaRequestsCallback = (streamRequests: StreamRequest[]) => void;
+type Kind = 'audio' | 'video';
+
+type Options = {
+  degradationPreferences: DegradationPreferences;
+  kind: Kind;
+};
 export class MediaRequestManager {
   private sendMediaRequestsCallback: SendMediaRequestsCallback;
 
-  private counter;
+  private kind: Kind;
+
+  private counter: number;
 
   private clientRequests: {[key: MediaRequestId]: MediaRequest};
 
-  private slotsActiveInLastMediaRequest: {[key: ReceiveSlotId]: ReceiveSlot};
+  private degradationPreferences: DegradationPreferences;
 
-  constructor(sendMediaRequestsCallback: SendMediaRequestsCallback) {
+  private sourceUpdateListener: () => void;
+
+  private debouncedSourceUpdateListener: () => void;
+
+  private previousStreamRequests: Array<StreamRequest> = [];
+
+  constructor(sendMediaRequestsCallback: SendMediaRequestsCallback, options: Options) {
     this.sendMediaRequestsCallback = sendMediaRequestsCallback;
     this.counter = 0;
     this.clientRequests = {};
-    this.slotsActiveInLastMediaRequest = {};
+    this.degradationPreferences = options.degradationPreferences;
+    this.kind = options.kind;
+    this.sourceUpdateListener = this.commit.bind(this);
+    this.debouncedSourceUpdateListener = debounce(
+      this.sourceUpdateListener,
+      DEBOUNCED_SOURCE_UPDATE_TIME
+    );
   }
 
-  private resetInactiveReceiveSlots() {
-    const activeSlots: {[key: ReceiveSlotId]: ReceiveSlot} = {};
-
-    // create a map of all currently used slot ids
-    Object.values(this.clientRequests).forEach((request) =>
-      request.receiveSlots.forEach((slot) => {
-        activeSlots[slot.id] = slot;
-      })
-    );
+  public setDegradationPreferences(degradationPreferences: DegradationPreferences) {
+    this.degradationPreferences = degradationPreferences;
+    this.sendRequests(); // re-send requests after preferences are set
+  }
 
-    // when we stop using some receive slots and they are not included in the new media request,
-    // we will never get a 'no source' notification for them, so we reset their state,
-    // so that the client doesn't try to display their video anymore
-    for (const [slotId, slot] of Object.entries(this.slotsActiveInLastMediaRequest)) {
-      if (!(slotId in activeSlots)) {
-        LoggerProxy.logger.info(
-          `multistream:mediaRequestManager --> resetting sourceState to "no source" for slot ${slot.id}`
+  private getDegradedClientRequests() {
+    const clientRequests = cloneDeep(this.clientRequests);
+    const maxFsLimits = [
+      getMaxFs('best'),
+      getMaxFs('large'),
+      getMaxFs('medium'),
+      getMaxFs('small'),
+      getMaxFs('very small'),
+      getMaxFs('thumbnail'),
+    ];
+
+    // reduce max-fs until total macroblocks is below limit
+    for (let i = 0; i < maxFsLimits.length; i += 1) {
+      let totalMacroblocksRequested = 0;
+      Object.entries(clientRequests).forEach(([id, mr]) => {
+        if (mr.codecInfo) {
+          mr.codecInfo.maxFs = Math.min(
+            mr.preferredMaxFs || CODEC_DEFAULTS.h264.maxFs,
+            mr.codecInfo.maxFs || CODEC_DEFAULTS.h264.maxFs,
+            maxFsLimits[i]
+          );
+          // we only consider sources with "live" state
+          const slotsWithLiveSource = this.clientRequests[id].receiveSlots.filter(
+            (rs) => rs.sourceState === 'live'
+          );
+          totalMacroblocksRequested += mr.codecInfo.maxFs * slotsWithLiveSource.length;
+        }
+      });
+      if (totalMacroblocksRequested <= this.degradationPreferences.maxMacroblocksLimit) {
+        if (i !== 0) {
+          LoggerProxy.logger.warn(
+            `multistream:mediaRequestManager --> too many streams with high max-fs, frame size will be limited to ${maxFsLimits[i]}`
+          );
+        }
+        break;
+      } else if (i === maxFsLimits.length - 1) {
+        LoggerProxy.logger.warn(
+          `multistream:mediaRequestManager --> even with frame size limited to ${maxFsLimits[i]} you are still requesting too many streams, consider reducing the number of requests`
         );
-        slot.resetSourceState();
       }
     }
 
-    this.slotsActiveInLastMediaRequest = activeSlots;
+    return clientRequests;
+  }
+
+  /**
+   * Returns true if two stream requests are the same, false otherwise.
+   *
+   * @param {StreamRequest} streamRequestA - Stream request A for comparison.
+   * @param {StreamRequest} streamRequestB - Stream request B for comparison.
+   * @returns {boolean} - Whether they are equal.
+   */
+  // eslint-disable-next-line class-methods-use-this
+  public isEqual(streamRequestA: StreamRequest, streamRequestB: StreamRequest) {
+    return (
+      JSON.stringify(streamRequestA._toJmpStreamRequest()) ===
+      JSON.stringify(streamRequestB._toJmpStreamRequest())
+    );
+  }
+
+  /**
+   * Compares new stream requests to previous ones and determines
+   * if they are the same.
+   *
+   * @param {StreamRequest[]} newRequests - Array with new requests.
+   * @returns {boolean} - True if they are equal, false otherwise.
+   */
+  private checkIsNewRequestsEqualToPrev(newRequests: StreamRequest[]) {
+    return (
+      !isEmpty(this.previousStreamRequests) &&
+      this.previousStreamRequests.length === newRequests.length &&
+      this.previousStreamRequests.every((req, idx) => this.isEqual(req, newRequests[idx]))
+    );
+  }
+
+  /**
+   * Returns the maxPayloadBitsPerSecond per Stream
+   *
+   * If MediaRequestManager kind is "audio", a constant bitrate will be returned.
+   * If MediaRequestManager kind is "video", the bitrate will be calculated based
+   * on maxFs (default h264 maxFs as fallback if maxFs is not defined)
+   *
+   * @param {MediaRequest} mediaRequest  - mediaRequest to take data from
+   * @returns {number} maxPayloadBitsPerSecond
+   */
+  private getMaxPayloadBitsPerSecond(mediaRequest: MediaRequest): number {
+    if (this.kind === 'audio') {
+      // return mono_music bitrate default if the kind of mediarequest manager is audio:
+      return RecommendedOpusBitrates.FB_MONO_MUSIC;
+    }
+
+    return getRecommendedMaxBitrateForFrameSize(
+      mediaRequest.codecInfo.maxFs || CODEC_DEFAULTS.h264.maxFs
+    );
+  }
+
+  /**
+   * Returns the max Macro Blocks per second (maxMbps) per H264 Stream
+   *
+   * The maxMbps will be calculated based on maxFs and maxFps
+   * (default h264 maxFps as fallback if maxFps is not defined)
+   *
+   * @param {MediaRequest} mediaRequest  - mediaRequest to take data from
+   * @returns {number} maxMbps
+   */
+  // eslint-disable-next-line class-methods-use-this
+  private getH264MaxMbps(mediaRequest: MediaRequest): number {
+    // fallback for maxFps (not needed for maxFs, since there is a fallback already in getDegradedClientRequests)
+    const maxFps = mediaRequest.codecInfo.maxFps || CODEC_DEFAULTS.h264.maxFps;
+
+    // divided by 100 since maxFps is 3000 (for 30 frames per seconds)
+    return (mediaRequest.codecInfo.maxFs * maxFps) / 100;
+  }
+
+  /**
+   * Clears the previous stream requests.
+   *
+   * @returns {void}
+   */
+  public clearPreviousRequests(): void {
+    this.previousStreamRequests = [];
   }
 
   private sendRequests() {
-    const wcmeMediaRequests: MC.MediaRequest[] = [];
+    const streamRequests: StreamRequest[] = [];
 
-    // todo: check how many streams we're asking for and what resolution and introduce some limits (spark-377701)
-    const maxPayloadBitsPerSecond = 10 * 1000 * 1000;
+    const clientRequests = this.getDegradedClientRequests();
 
-    // map all the client media requests to wcme media requests
-    Object.values(this.clientRequests).forEach((mr) => {
-      wcmeMediaRequests.push(
-        new MC.MediaRequest(
+    // map all the client media requests to wcme stream requests
+    Object.values(clientRequests).forEach((mr) => {
+      streamRequests.push(
+        new StreamRequest(
           mr.policyInfo.policy === 'active-speaker'
-            ? MC.Policy.ActiveSpeaker
-            : MC.Policy.ReceiverSelected,
+            ? Policy.ActiveSpeaker
+            : Policy.ReceiverSelected,
           mr.policyInfo.policy === 'active-speaker'
-            ? new MC.ActiveSpeakerInfo(
+            ? new ActiveSpeakerInfo(
                 mr.policyInfo.priority,
                 mr.policyInfo.crossPriorityDuplication,
                 mr.policyInfo.crossPolicyDuplication,
                 mr.policyInfo.preferLiveVideo
               )
-            : new MC.ReceiverSelectedInfo(mr.policyInfo.csi),
+            : new ReceiverSelectedInfo(mr.policyInfo.csi),
           mr.receiveSlots.map((receiveSlot) => receiveSlot.wcmeReceiveSlot),
-          maxPayloadBitsPerSecond,
+          this.getMaxPayloadBitsPerSecond(mr),
           mr.codecInfo && [
-            new MC.CodecInfo(
+            new WcmeCodecInfo(
               0x80,
-              new MC.H264Codec(
-                mr.codecInfo.maxFs || CODEC_DEFAULTS.h264.maxFs,
+              new H264Codec(
+                mr.codecInfo.maxFs,
                 mr.codecInfo.maxFps || CODEC_DEFAULTS.h264.maxFps,
-                mr.codecInfo.maxMbps || CODEC_DEFAULTS.h264.maxMbps,
+                this.getH264MaxMbps(mr),
                 mr.codecInfo.maxWidth,
                 mr.codecInfo.maxHeight
               )
@@ -129,9 +269,17 @@ export class MediaRequestManager {
       );
     });
 
-    this.sendMediaRequestsCallback(wcmeMediaRequests);
-
-    this.resetInactiveReceiveSlots();
+    //! IMPORTANT: this is only a temporary fix. This will soon be done in the jmp layer (@webex/json-multistream)
+    // https://jira-eng-gpk2.cisco.com/jira/browse/WEBEX-326713
+    if (!this.checkIsNewRequestsEqualToPrev(streamRequests)) {
+      this.sendMediaRequestsCallback(streamRequests);
+      this.previousStreamRequests = streamRequests;
+      LoggerProxy.logger.info(`multistream:sendRequests --> media requests sent. `);
+    } else {
+      LoggerProxy.logger.info(
+        `multistream:sendRequests --> detected duplicate WCME requests, skipping them... `
+      );
+    }
   }
 
   public addRequest(mediaRequest: MediaRequest, commit = true): MediaRequestId {
@@ -140,6 +288,17 @@ export class MediaRequestManager {
 
     this.clientRequests[newId] = mediaRequest;
 
+    const eventHandler = ({maxFs}) => {
+      mediaRequest.preferredMaxFs = maxFs;
+      this.debouncedSourceUpdateListener();
+    };
+    mediaRequest.handleMaxFs = eventHandler;
+
+    mediaRequest.receiveSlots.forEach((rs) => {
+      rs.on(ReceiveSlotEvents.SourceUpdate, this.sourceUpdateListener);
+      rs.on(ReceiveSlotEvents.MaxFsUpdate, mediaRequest.handleMaxFs);
+    });
+
     if (commit) {
       this.commit();
     }
@@ -148,6 +307,13 @@ export class MediaRequestManager {
   }
 
   public cancelRequest(requestId: MediaRequestId, commit = true) {
+    const mediaRequest = this.clientRequests[requestId];
+
+    mediaRequest?.receiveSlots.forEach((rs) => {
+      rs.off(ReceiveSlotEvents.SourceUpdate, this.sourceUpdateListener);
+      rs.off(ReceiveSlotEvents.MaxFsUpdate, mediaRequest.handleMaxFs);
+    });
+
     delete this.clientRequests[requestId];
 
     if (commit) {
@@ -161,6 +327,5 @@ export class MediaRequestManager {
 
   public reset() {
     this.clientRequests = {};
-    this.slotsActiveInLastMediaRequest = {};
   }
 }

package/src/multistream/receiveSlot.ts

@@ -1,13 +1,20 @@
-import {MediaConnection as MC} from '@webex/internal-media-core';
+/* 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 SourceState = MC.SourceState;
+export type {StreamState} from '@webex/internal-media-core';
 export type CSI = number;
 export type MemberId = string;
 export type ReceiveSlotId = string;
@@ -21,31 +28,31 @@ export type FindMemberIdCallback = (csi: CSI) => MemberId | undefined;
  * for example some participant's main video or audio
  */
 export class ReceiveSlot extends EventsScope {
-  private readonly mcReceiveSlot: MC.ReceiveSlot;
+  private readonly mcReceiveSlot: WcmeReceiveSlot;
 
   private readonly findMemberIdCallback: FindMemberIdCallback;
 
   public readonly id: ReceiveSlotId;
 
-  public readonly mediaType: MC.MediaType;
+  public readonly mediaType: MediaType;
 
   #memberId?: MemberId;
 
   #csi?: CSI;
 
-  #sourceState: MC.SourceState;
+  #sourceState: StreamState;
 
   /**
    * constructor - don't use it directly, you should always use meeting.receiveSlotManager.allocateSlot()
    * to create any receive slots
    *
-   * @param {MC.MediaType} mediaType
-   * @param {MC.ReceiveSlot} mcReceiveSlot
+   * @param {MediaType} mediaType
+   * @param {ReceiveSlot} mcReceiveSlot
    * @param {FindMemberIdCallback} findMemberIdCallback callback for finding memberId for given CSI
    */
   constructor(
-    mediaType: MC.MediaType,
-    mcReceiveSlot: MC.ReceiveSlot,
+    mediaType: MediaType,
+    mcReceiveSlot: WcmeReceiveSlot,
     findMemberIdCallback: FindMemberIdCallback
   ) {
     super();
@@ -75,6 +82,25 @@ export class ReceiveSlot extends EventsScope {
     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
    */
@@ -85,15 +111,15 @@ export class ReceiveSlot extends EventsScope {
   /**
    * registers event handlers with the underlying ReceiveSlot
    */
-  setupEventListeners() {
+  private setupEventListeners() {
     const scope = {
       file: 'meeting/receiveSlot',
       function: 'setupEventListeners',
     };
 
     this.mcReceiveSlot.on(
-      MC.ReceiveSlotEvents.SourceUpdate,
-      (state: MC.SourceState, csi?: number) => {
+      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}`
         );
@@ -110,6 +136,36 @@ export class ReceiveSlot extends EventsScope {
     );
   }
 
+  /** 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.
    *
@@ -122,20 +178,7 @@ export class ReceiveSlot extends EventsScope {
   /**
    * The underlying WCME receive slot
    */
-  get wcmeReceiveSlot(): MC.ReceiveSlot {
+  get wcmeReceiveSlot(): WcmeReceiveSlot {
     return this.mcReceiveSlot;
   }
-
-  /**
-   * Resets the source state to the default 'no source' value.
-   * This function should be called on receive slots that are
-   * no longer part of a media request. It's needed because WCME
-   * does not send any more events on such slots, so the sourceState
-   * value would not represent the truth anymore.
-   */
-  public resetSourceState() {
-    this.#sourceState = 'no source';
-    this.#csi = undefined;
-    this.#memberId = undefined;
-  }
 }

package/src/multistream/receiveSlotManager.ts

@@ -1,53 +1,58 @@
+/* eslint-disable valid-jsdoc */
 /* eslint-disable import/prefer-default-export */
-import {MediaConnection as MC} from '@webex/internal-media-core';
-
+import {MediaType, ReceiveSlot as WcmeReceiveSlot} from '@webex/internal-media-core';
 import LoggerProxy from '../common/logs/logger-proxy';
-import Meeting from '../meeting';
 
-import {CSI, ReceiveSlot} from './receiveSlot';
+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 MC.MediaType]: ReceiveSlot[]};
+  private allocatedSlots: {[key in MediaType]: ReceiveSlot[]};
 
-  private freeSlots: {[key in MC.MediaType]: ReceiveSlot[]};
+  private freeSlots: {[key in MediaType]: ReceiveSlot[]};
 
-  private meeting: Meeting;
+  private createSlotCallback: CreateSlotCallback;
+
+  private findMemberIdByCsiCallback: FindMemberIdCallback;
 
   /**
    * Constructor
    * @param {Meeting} meeting
    */
-  constructor(meeting) {
+  constructor(
+    createSlotCallback: CreateSlotCallback,
+    findMemberIdByCsiCallback: FindMemberIdCallback
+  ) {
     this.allocatedSlots = {
-      [MC.MediaType.AudioMain]: [],
-      [MC.MediaType.VideoMain]: [],
-      [MC.MediaType.AudioSlides]: [],
-      [MC.MediaType.VideoSlides]: [],
+      [MediaType.AudioMain]: [],
+      [MediaType.VideoMain]: [],
+      [MediaType.AudioSlides]: [],
+      [MediaType.VideoSlides]: [],
     };
     this.freeSlots = {
-      [MC.MediaType.AudioMain]: [],
-      [MC.MediaType.VideoMain]: [],
-      [MC.MediaType.AudioSlides]: [],
-      [MC.MediaType.VideoSlides]: [],
+      [MediaType.AudioMain]: [],
+      [MediaType.VideoMain]: [],
+      [MediaType.AudioSlides]: [],
+      [MediaType.VideoSlides]: [],
     };
-    this.meeting = meeting;
+    this.createSlotCallback = createSlotCallback;
+    this.findMemberIdByCsiCallback = findMemberIdByCsiCallback;
   }
 
   /**
    * Creates a new receive slot or returns one from the existing pool of free slots
    *
-   * @param {MC.MediaType} mediaType
+   * @param {MediaType} mediaType
    * @returns {Promise<ReceiveSlot>}
    */
-  async allocateSlot(mediaType: MC.MediaType): Promise<ReceiveSlot> {
-    if (!this.meeting?.mediaProperties?.webrtcMediaConnection) {
-      return Promise.reject(new Error('Webrtc media connection is missing'));
-    }
-
+  async allocateSlot(mediaType: MediaType): Promise<ReceiveSlot> {
     // try to use one of the free ones
     const availableSlot = this.freeSlots[mediaType].pop();
 
@@ -60,14 +65,9 @@ export class ReceiveSlotManager {
     }
 
     // we have to create a new one
-    const wcmeReceiveSlot =
-      await this.meeting.mediaProperties.webrtcMediaConnection.createReceiveSlot(mediaType);
+    const wcmeReceiveSlot = await this.createSlotCallback(mediaType);
 
-    const receiveSlot = new ReceiveSlot(
-      mediaType,
-      wcmeReceiveSlot,
-      (csi: CSI) => this.meeting.members.findMemberByCsi(csi)?.id
-    );
+    const receiveSlot = new ReceiveSlot(mediaType, wcmeReceiveSlot, this.findMemberIdByCsiCallback);
 
     this.allocatedSlots[mediaType].push(receiveSlot);
     LoggerProxy.logger.log(`new receive slot allocated: ${receiveSlot.id}`);
@@ -100,16 +100,16 @@ export class ReceiveSlotManager {
    */
   reset() {
     this.allocatedSlots = {
-      [MC.MediaType.AudioMain]: [],
-      [MC.MediaType.VideoMain]: [],
-      [MC.MediaType.AudioSlides]: [],
-      [MC.MediaType.VideoSlides]: [],
+      [MediaType.AudioMain]: [],
+      [MediaType.VideoMain]: [],
+      [MediaType.AudioSlides]: [],
+      [MediaType.VideoSlides]: [],
     };
     this.freeSlots = {
-      [MC.MediaType.AudioMain]: [],
-      [MC.MediaType.VideoMain]: [],
-      [MC.MediaType.AudioSlides]: [],
-      [MC.MediaType.VideoSlides]: [],
+      [MediaType.AudioMain]: [],
+      [MediaType.VideoMain]: [],
+      [MediaType.AudioSlides]: [],
+      [MediaType.VideoSlides]: [],
     };
   }
 
@@ -139,4 +139,28 @@ export class ReceiveSlotManager {
       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);
+  }
 }