@webex/plugin-meetings 3.12.0-next.6 → 3.12.0-next.60

package/src/multistream/codec/constants.ts

@@ -0,0 +1,58 @@
+import {AV1EncodingParams, SupportedResolution} from '@webex/internal-media-core';
+
+export const AV1_CODEC_PARAMETERS: Record<SupportedResolution, AV1EncodingParams> = {
+  '90p': {
+    levelIdx: 0,
+    tier: 0,
+    maxWidth: 160,
+    maxHeight: 90,
+    maxPicSize: 160 * 90,
+    maxDecodeRate: 5_529_600,
+  },
+  '180p': {
+    levelIdx: 0,
+    tier: 0,
+    maxWidth: 320,
+    maxHeight: 180,
+    maxPicSize: 320 * 180,
+    maxDecodeRate: 5_529_600,
+  },
+  '360p': {
+    levelIdx: 1,
+    tier: 0,
+    maxWidth: 640,
+    maxHeight: 360,
+    maxPicSize: 640 * 360,
+    maxDecodeRate: 10_454_400,
+  },
+  '540p': {
+    levelIdx: 4,
+    tier: 0,
+    maxWidth: 960,
+    maxHeight: 540,
+    maxPicSize: 960 * 540,
+    maxDecodeRate: 24_969_600,
+  },
+  '720p': {
+    levelIdx: 5,
+    tier: 0,
+    maxWidth: 1280,
+    maxHeight: 720,
+    maxPicSize: 1280 * 720,
+    maxDecodeRate: 39_938_400,
+  },
+  '1080p': {
+    levelIdx: 8,
+    tier: 0,
+    maxWidth: 1920,
+    maxHeight: 1080,
+    maxPicSize: 1920 * 1080,
+    maxDecodeRate: 77_856_768,
+  },
+};
+
+export const H264_CODEC_PARAMETERS = {
+  maxFs: 8192,
+  maxFps: 3000,
+  maxMbps: 245760,
+};

package/src/multistream/mediaRequestManager.ts

@@ -9,6 +9,11 @@ import {
   getRecommendedMaxBitrateForFrameSize,
   RecommendedOpusBitrates,
   NamedMediaGroup,
+  AV1Codec,
+  SupportedResolution,
+  AV1EncodingParams,
+  MediaType,
+  MediaCodecMimeType,
 } from '@webex/internal-media-core';
 import {cloneDeepWith, debounce} from 'lodash';
 
@@ -16,6 +21,7 @@ import LoggerProxy from '../common/logs/logger-proxy';
 
 import {ReceiveSlot, ReceiveSlotEvents} from './receiveSlot';
 import {MAX_FS_VALUES} from './remoteMedia';
+import {AV1_CODEC_PARAMETERS, H264_CODEC_PARAMETERS} from './codec/constants';
 
 export interface ActiveSpeakerPolicyInfo {
   policy: 'active-speaker';
@@ -54,34 +60,49 @@ export interface MediaRequest {
 
 export type MediaRequestId = string;
 
-const CODEC_DEFAULTS = {
-  h264: {
-    maxFs: 8192,
-    maxFps: 3000,
-    maxMbps: 245760,
-  },
-};
-
 const DEBOUNCED_SOURCE_UPDATE_TIME = 1000;
 
+const RESOLUTION_BUCKETS: Array<[SupportedResolution, number]> = [
+  ['90p', MAX_FS_VALUES['90p']],
+  ['180p', MAX_FS_VALUES['180p']],
+  ['360p', MAX_FS_VALUES['360p']],
+  ['540p', MAX_FS_VALUES['540p']],
+  ['720p', MAX_FS_VALUES['720p']],
+];
+
 type DegradationPreferences = {
   maxMacroblocksLimit: number;
 };
 
 type SendMediaRequestsCallback = (streamRequests: StreamRequest[]) => void;
+type GetIngressPayloadTypeCallback = (
+  mediaType: MediaType,
+  codecMimeType: MediaCodecMimeType
+) => number | undefined;
 type Kind = 'audio' | 'video';
 
-type Options = {
+type AudioMediaRequestManagerOptions = {
   degradationPreferences: DegradationPreferences;
-  kind: Kind;
+  kind: 'audio';
   trimRequestsToNumOfSources: boolean; // if enabled, AS speaker requests will be trimmed based on the calls to setNumCurrentSources()
 };
 
+type VideoMediaRequestManagerOptions = {
+  degradationPreferences: DegradationPreferences;
+  kind: 'video';
+  trimRequestsToNumOfSources: boolean;
+  enableAv1?: boolean;
+};
+
+type Options = AudioMediaRequestManagerOptions | VideoMediaRequestManagerOptions;
+
 type ClientRequestsMap = {[key: MediaRequestId]: MediaRequest};
 
 export class MediaRequestManager {
   private sendMediaRequestsCallback: SendMediaRequestsCallback;
 
+  private getIngressPayloadTypeCallback: GetIngressPayloadTypeCallback;
+
   private kind: Kind;
 
   private counter: number;
@@ -95,11 +116,17 @@ export class MediaRequestManager {
   private debouncedSourceUpdateListener: () => void;
 
   private trimRequestsToNumOfSources: boolean;
+  private enableAv1: boolean;
   private numTotalSources: number;
   private numLiveSources: number;
 
-  constructor(sendMediaRequestsCallback: SendMediaRequestsCallback, options: Options) {
+  constructor(
+    sendMediaRequestsCallback: SendMediaRequestsCallback,
+    getIngressPayloadTypeCallback: GetIngressPayloadTypeCallback,
+    options: Options
+  ) {
     this.sendMediaRequestsCallback = sendMediaRequestsCallback;
+    this.getIngressPayloadTypeCallback = getIngressPayloadTypeCallback;
     this.counter = 0;
     this.numLiveSources = 0;
     this.numTotalSources = 0;
@@ -107,6 +134,7 @@ export class MediaRequestManager {
     this.degradationPreferences = options.degradationPreferences;
     this.kind = options.kind;
     this.trimRequestsToNumOfSources = options.trimRequestsToNumOfSources;
+    this.enableAv1 = options.kind === 'video' && !!options.enableAv1;
     this.sourceUpdateListener = this.commit.bind(this);
     this.debouncedSourceUpdateListener = debounce(
       this.sourceUpdateListener,
@@ -135,8 +163,8 @@ export class MediaRequestManager {
       Object.values(clientRequests).forEach((mr) => {
         if (mr.codecInfo) {
           mr.codecInfo.maxFs = Math.min(
-            mr.preferredMaxFs || CODEC_DEFAULTS.h264.maxFs,
-            mr.codecInfo.maxFs || CODEC_DEFAULTS.h264.maxFs,
+            mr.preferredMaxFs || H264_CODEC_PARAMETERS.maxFs,
+            mr.codecInfo.maxFs || H264_CODEC_PARAMETERS.maxFs,
             maxFsLimits[i]
           );
           // we only consider sources with "live" state
@@ -176,7 +204,7 @@ export class MediaRequestManager {
     }
 
     return getRecommendedMaxBitrateForFrameSize(
-      mediaRequest.codecInfo.maxFs || CODEC_DEFAULTS.h264.maxFs
+      mediaRequest.codecInfo.maxFs || H264_CODEC_PARAMETERS.maxFs
     );
   }
 
@@ -192,12 +220,80 @@ export class MediaRequestManager {
   // 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;
+    const maxFps = mediaRequest.codecInfo.maxFps || H264_CODEC_PARAMETERS.maxFps;
 
     // divided by 100 since maxFps is 3000 (for 30 frames per seconds)
     return (mediaRequest.codecInfo.maxFs * maxFps) / 100;
   }
 
+  /**
+   * Returns the AV1 encoding parameters for a media request
+   * @param mediaRequest - The media request to get the AV1 encoding parameters for
+   * @returns {AV1EncodingParams} The AV1 encoding parameters
+   */
+  // eslint-disable-next-line class-methods-use-this
+  private getAv1EncodingParams(mediaRequest: MediaRequest): AV1EncodingParams {
+    const frameSize = mediaRequest.codecInfo.maxFs || H264_CODEC_PARAMETERS.maxFs;
+    const resolution = RESOLUTION_BUCKETS.find(([, maxFs]) => frameSize <= maxFs)?.[0] ?? '1080p';
+
+    return AV1_CODEC_PARAMETERS[resolution];
+  }
+
+  private buildH264CodecInfo(mr: MediaRequest): WcmeCodecInfo | undefined {
+    if (!mr.codecInfo) {
+      return undefined;
+    }
+
+    const h264PayloadType = this.getIngressPayloadTypeCallback(
+      mr.receiveSlots[0].mediaType,
+      MediaCodecMimeType.H264
+    );
+
+    if (h264PayloadType === undefined) {
+      return undefined;
+    }
+
+    return WcmeCodecInfo.fromH264(
+      h264PayloadType,
+      new H264Codec(
+        mr.codecInfo.maxFs,
+        mr.codecInfo.maxFps || H264_CODEC_PARAMETERS.maxFps,
+        this.getH264MaxMbps(mr),
+        mr.codecInfo.maxWidth,
+        mr.codecInfo.maxHeight
+      )
+    );
+  }
+
+  private buildAv1CodecInfo(mr: MediaRequest): WcmeCodecInfo | undefined {
+    if (!this.enableAv1 || !mr.codecInfo) {
+      return undefined;
+    }
+
+    const av1PayloadType = this.getIngressPayloadTypeCallback(
+      mr.receiveSlots[0].mediaType,
+      MediaCodecMimeType.AV1
+    );
+
+    if (av1PayloadType === undefined) {
+      return undefined;
+    }
+
+    const av1EncodingParams = this.getAv1EncodingParams(mr);
+
+    return WcmeCodecInfo.fromAv1(
+      av1PayloadType,
+      new AV1Codec(
+        av1EncodingParams.levelIdx,
+        av1EncodingParams.tier,
+        mr.codecInfo.maxWidth || av1EncodingParams.maxWidth,
+        mr.codecInfo.maxHeight || av1EncodingParams.maxHeight,
+        av1EncodingParams.maxPicSize,
+        av1EncodingParams.maxDecodeRate
+      )
+    );
+  }
+
   /** Modifies the passed in clientRequests and makes sure that in total they don't ask
    *  for more streams than there are available.
    *
@@ -298,6 +394,12 @@ export class MediaRequestManager {
     // map all the client media requests to wcme stream requests
     Object.values(clientRequests).forEach((mr) => {
       if (mr.receiveSlots.length > 0) {
+        const codecInfos: WcmeCodecInfo[] = mr.codecInfo
+          ? [this.buildH264CodecInfo(mr), this.buildAv1CodecInfo(mr)].filter(
+              (info): info is WcmeCodecInfo => info !== undefined
+            )
+          : [];
+
         streamRequests.push(
           new StreamRequest(
             mr.policyInfo.policy === 'active-speaker'
@@ -314,25 +416,14 @@ export class MediaRequestManager {
               : new ReceiverSelectedInfo(mr.policyInfo.csi),
             mr.receiveSlots.map((receiveSlot) => receiveSlot.wcmeReceiveSlot),
             this.getMaxPayloadBitsPerSecond(mr),
-            mr.codecInfo && [
-              WcmeCodecInfo.fromH264(
-                0x80,
-                new H264Codec(
-                  mr.codecInfo.maxFs,
-                  mr.codecInfo.maxFps || CODEC_DEFAULTS.h264.maxFps,
-                  this.getH264MaxMbps(mr),
-                  mr.codecInfo.maxWidth,
-                  mr.codecInfo.maxHeight
-                )
-              ),
-            ]
+            codecInfos
           )
         );
       }
     });
 
     this.sendMediaRequestsCallback(streamRequests);
-    LoggerProxy.logger.info(`multistream:sendRequests --> media requests sent. `);
+    LoggerProxy.logger.info(`multistream:sendRequests --> media requests sent.`);
   }
 
   public addRequest(mediaRequest: MediaRequest, commit = true): MediaRequestId {

package/src/multistream/receiveSlot.ts

@@ -134,6 +134,24 @@ export class ReceiveSlot extends EventsScope {
         });
       }
     );
+
+    this.mcReceiveSlot.on(WcmeReceiveSlotEvents.MediaStarted, () => {
+      LoggerProxy.logger.log(
+        `ReceiveSlot#setupEventListeners --> media started on receive slot ${this.id}, mediaType=${this.mediaType}`
+      );
+    });
+
+    this.mcReceiveSlot.on(WcmeReceiveSlotEvents.MediaStopped, () => {
+      LoggerProxy.logger.log(
+        `ReceiveSlot#setupEventListeners --> media stopped on receive slot ${this.id}, mediaType=${this.mediaType}`
+      );
+    });
+
+    this.mcReceiveSlot.on(WcmeReceiveSlotEvents.MediaEnded, () => {
+      LoggerProxy.logger.log(
+        `ReceiveSlot#setupEventListeners --> media ended on receive slot ${this.id}, mediaType=${this.mediaType}`
+      );
+    });
   }
 
   /** Tries to find the member id for this receive slot if it hasn't got one */

package/src/reactions/reactions.type.ts

@@ -60,4 +60,7 @@ type RelayEventData = {
 
 export type RelayEvent = {
   data: RelayEventData;
+  headers?: {
+    route?: string;
+  };
 };

package/src/recording-controller/index.ts

@@ -261,8 +261,7 @@ export default class RecordingController {
 
     LoggerProxy.logger.log(`RecordingController:index#recordingControls --> ${record}`);
 
-    // @ts-ignore
-    return this.request.request({
+    return this.request.locusDeltaRequest({
       uri: `${this.locusUrl}/${CONTROLS}`,
       body: {
         record,

package/src/webinar/index.ts

@@ -18,6 +18,7 @@ import {
 
 import WebinarCollection from './collection';
 import LoggerProxy from '../common/logs/logger-proxy';
+import MeetingUtil from '../meeting/util';
 import {sanitizeParams} from './utils';
 
 /**
@@ -98,13 +99,49 @@ const Webinar = WebexPlugin.extend({
     return {isPromoted, isDemoted};
   },
 
+  /**
+   * Resolves the meeting associated with this webinar instance, guarded against the
+   * meetingId pointer drifting onto an unrelated transient meeting (e.g. an inbound
+   * 1:1 call) that may exist in the meeting collection. Returns the meeting only when
+   * its locusUrl matches this webinar's tracked locusUrl. Returns undefined (with a
+   * warning) when the meeting cannot be resolved or when the webinar's locusUrl has
+   * not been initialized yet — callers must treat this as "no owned meeting" rather
+   * than fall through to an unvalidated lookup.
+   * @returns {object|undefined}
+   */
+  getValidatedWebinarMeeting() {
+    const meeting = this.webex.meetings.getMeetingByType(_ID_, this.meetingId);
+
+    if (!meeting) {
+      return undefined;
+    }
+
+    if (!this.locusUrl) {
+      LoggerProxy.logger.warn(
+        `Webinar:index#getValidatedWebinarMeeting --> skipping; webinar locusUrl is not yet initialized for meetingId ${this.meetingId}`
+      );
+
+      return undefined;
+    }
+
+    if (meeting.locusUrl !== this.locusUrl) {
+      LoggerProxy.logger.warn(
+        `Webinar:index#getValidatedWebinarMeeting --> skipping; meeting ${this.meetingId} locusUrl ${meeting.locusUrl} does not match webinar locusUrl ${this.locusUrl}`
+      );
+
+      return undefined;
+    }
+
+    return meeting;
+  },
+
   /**
    * should join practice session data channel or not
    * @param {Object} {isPromoted: boolean, isDemoted: boolean}} Role transition states
    * @returns {void}
    */
   updateStatusByRole({isPromoted, isDemoted}) {
-    const meeting = this.webex.meetings.getMeetingByType(_ID_, this.meetingId);
+    const meeting = this.getValidatedWebinarMeeting();
 
     if (
       (isDemoted && meeting?.shareStatus === SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE) ||
@@ -128,6 +165,9 @@ const Webinar = WebexPlugin.extend({
 
   /**
    * Disconnects the practice session data channel and removes its relay listener.
+   * The listener reference removed here is the exact callback captured at subscribe
+   * time (see updatePSDataChannel) so that cleanup is correct even if the underlying
+   * meeting can no longer be resolved (e.g. locusUrl mismatch).
    * @returns {Promise<void>}
    */
   async cleanupPSDataChannel() {
@@ -137,8 +177,6 @@ const Webinar = WebexPlugin.extend({
       this._pendingOnlineListener = null;
     }
 
-    const meeting = this.webex.meetings.getMeetingByType(_ID_, this.meetingId);
-
     // @ts-ignore - Fix type
     await this.webex.internal.llm.disconnectLLM(
       {
@@ -147,11 +185,65 @@ const Webinar = WebexPlugin.extend({
       },
       LLM_PRACTICE_SESSION
     );
-    // @ts-ignore - Fix type
-    this.webex.internal.llm.off(
-      `event:relay.event:${LLM_PRACTICE_SESSION}`,
-      meeting?.processRelayEvent
+
+    if (this._practiceSessionRelayListener) {
+      // @ts-ignore - Fix type
+      this.webex.internal.llm.off(
+        `event:relay.event:${LLM_PRACTICE_SESSION}`,
+        this._practiceSessionRelayListener
+      );
+      this._practiceSessionRelayListener = null;
+    }
+  },
+
+  /**
+   * Ensures practice-session token exists before registering the practice LLM channel.
+   * Caller is responsible for passing a meeting that has already been resolved via
+   * getValidatedWebinarMeeting() — this method does not re-validate ownership.
+   * @param {object} meeting
+   * @returns {Promise<string|undefined>}
+   */
+  async ensurePracticeSessionDatachannelToken(meeting) {
+    // @ts-ignore
+    const isDataChannelTokenEnabled = await this.webex.internal.llm.isDataChannelTokenEnabled();
+
+    if (!isDataChannelTokenEnabled) {
+      return undefined;
+    }
+
+    // @ts-ignore
+    const cachedToken = this.webex.internal.llm.getDatachannelToken(
+      DataChannelTokenType.PracticeSession
     );
+
+    if (cachedToken) {
+      return cachedToken;
+    }
+
+    try {
+      const refreshResponse = await meeting.refreshDataChannelToken();
+      const {datachannelToken, dataChannelTokenType} = refreshResponse?.body ?? {};
+
+      if (!datachannelToken) {
+        return undefined;
+      }
+
+      // @ts-ignore
+      this.webex.internal.llm.setDatachannelToken(
+        datachannelToken,
+        dataChannelTokenType || DataChannelTokenType.PracticeSession
+      );
+
+      return datachannelToken;
+    } catch (error) {
+      LoggerProxy.logger.warn(
+        `Webinar:index#ensurePracticeSessionDatachannelToken --> failed to proactively refresh practice-session token: ${
+          error?.message || String(error)
+        }`
+      );
+
+      return undefined;
+    }
   },
 
   /**
@@ -160,7 +252,10 @@ const Webinar = WebexPlugin.extend({
    * @returns {Promise}
    */
   async updatePSDataChannel() {
-    const meeting = this.webex.meetings.getMeetingByType(_ID_, this.meetingId);
+    this._updatePSDataChannelSequence = (this._updatePSDataChannelSequence || 0) + 1;
+    const invocationSequence = this._updatePSDataChannelSequence;
+
+    const meeting = this.getValidatedWebinarMeeting();
     const isPracticeSession = meeting?.isJoined() && this.isJoinPracticeSessionDataChannel();
 
     if (!isPracticeSession) {
@@ -174,7 +269,7 @@ const Webinar = WebexPlugin.extend({
       meeting?.locusInfo || {};
 
     // @ts-ignore
-    const practiceSessionDatachannelToken = this.webex.internal.llm.getDatachannelToken(
+    let practiceSessionDatachannelToken = this.webex.internal.llm.getDatachannelToken(
       DataChannelTokenType.PracticeSession
     );
 
@@ -229,6 +324,29 @@ const Webinar = WebexPlugin.extend({
       this._pendingOnlineListener = null;
     }
 
+    const refreshedPracticeSessionToken = await this.ensurePracticeSessionDatachannelToken(meeting);
+
+    const latestPracticeSessionDatachannelUrl = get(
+      meeting,
+      'locusInfo.info.practiceSessionDatachannelUrl'
+    );
+    const isStillPracticeSession = meeting?.isJoined() && this.isJoinPracticeSessionDataChannel();
+
+    // Skip stale invocations after async refresh to avoid reconnecting a session
+    // that was already updated/cleaned by a newer state transition.
+    if (
+      invocationSequence !== this._updatePSDataChannelSequence ||
+      !isStillPracticeSession ||
+      !latestPracticeSessionDatachannelUrl ||
+      latestPracticeSessionDatachannelUrl !== practiceSessionDatachannelUrl
+    ) {
+      return undefined;
+    }
+
+    if (refreshedPracticeSessionToken) {
+      practiceSessionDatachannelToken = refreshedPracticeSessionToken;
+    }
+
     // @ts-ignore - Fix type
     return this.webex.internal.llm
       .registerAndConnect(
@@ -238,15 +356,21 @@ const Webinar = WebexPlugin.extend({
         LLM_PRACTICE_SESSION
       )
       .then((registerAndConnectResult) => {
-        // @ts-ignore - Fix type
-        this.webex.internal.llm.off(
-          `event:relay.event:${LLM_PRACTICE_SESSION}`,
-          meeting?.processRelayEvent
-        );
+        // Track the exact listener reference so cleanupPSDataChannel can
+        // unsubscribe deterministically, even if the meeting can no longer
+        // be resolved at cleanup time.
+        if (this._practiceSessionRelayListener) {
+          // @ts-ignore - Fix type
+          this.webex.internal.llm.off(
+            `event:relay.event:${LLM_PRACTICE_SESSION}`,
+            this._practiceSessionRelayListener
+          );
+        }
+        this._practiceSessionRelayListener = meeting?.processRelayEvent;
         // @ts-ignore - Fix type
         this.webex.internal.llm.on(
           `event:relay.event:${LLM_PRACTICE_SESSION}`,
-          meeting?.processRelayEvent
+          this._practiceSessionRelayListener
         );
         // @ts-ignore - Fix type
         this.webex.internal.voicea?.announce?.();
@@ -267,6 +391,8 @@ const Webinar = WebexPlugin.extend({
    * @returns {Promise}
    */
   setPracticeSessionState(enabled) {
+    const meeting = this.getValidatedWebinarMeeting();
+
     return this.request({
       method: HTTP_VERBS.PATCH,
       uri: `${this.locusUrl}/controls`,
@@ -275,10 +401,16 @@ const Webinar = WebexPlugin.extend({
           enabled,
         },
       },
-    }).catch((error) => {
-      LoggerProxy.logger.error('Meeting:webinar#setPracticeSessionState failed', error);
-      throw error;
-    });
+    })
+      .then((response) => {
+        MeetingUtil.updateLocusFromApiResponse(meeting, response);
+
+        return response;
+      })
+      .catch((error) => {
+        LoggerProxy.logger.error('Meeting:webinar#setPracticeSessionState failed', error);
+        throw error;
+      });
   },
 
   /**
@@ -458,7 +590,14 @@ const Webinar = WebexPlugin.extend({
    * @returns {Promise}
    */
   async searchLargeScaleWebinarAttendees(payload) {
-    const meeting = this.webex.meetings.getMeetingByType(_ID_, this.meetingId);
+    const meeting = this.getValidatedWebinarMeeting();
+    if (!meeting) {
+      LoggerProxy.logger.error(
+        'Meeting:webinar5k#searchLargeScaleWebinarAttendees failed --> webinar meeting could not be validated'
+      );
+      throw new Error('Meeting:webinar5k#Webinar meeting is not resolvable for the current locus');
+    }
+
     const rawParams = {
       search_text: payload?.queryString,
       limit: payload?.limit ?? DEFAULT_LARGE_SCALE_WEBINAR_ATTENDEE_SEARCH_LIMIT,
@@ -466,7 +605,9 @@ const Webinar = WebexPlugin.extend({
     };
     const attendeeSearchUrl = meeting?.locusInfo?.links?.resources?.attendeeSearch?.url;
     if (!attendeeSearchUrl) {
-      LoggerProxy.logger.error(`Meeting:webinar5k#searchLargeScaleWebinarAttendees failed`);
+      LoggerProxy.logger.error(
+        'Meeting:webinar5k#searchLargeScaleWebinarAttendees failed --> attendee search url unavailable'
+      );
       throw new Error('Meeting:webinar5k#Attendee search url is not available');
     }