@webex/plugin-meetings 3.8.1-next.29 → 3.8.1-next.30

package/src/constants.ts

@@ -1189,6 +1189,7 @@ export const QUALITY_LEVELS = {
   HIGH: 'HIGH',
   '360p': '360p',
   '480p': '480p',
+  '540p': '540p',
   '720p': '720p',
   '1080p': '1080p',
 };
@@ -1218,6 +1219,18 @@ export const AVAILABLE_RESOLUTIONS = {
       },
     },
   },
+  '540p': {
+    video: {
+      width: {
+        max: 960,
+        ideal: 960,
+      },
+      height: {
+        max: 540,
+        ideal: 540,
+      },
+    },
+  },
   '720p': {
     video: {
       width: {

package/src/multistream/mediaRequestManager.ts

@@ -15,7 +15,7 @@ import {cloneDeepWith, debounce, isEmpty} from 'lodash';
 import LoggerProxy from '../common/logs/logger-proxy';
 
 import {ReceiveSlot, ReceiveSlotEvents} from './receiveSlot';
-import {getMaxFs} from './remoteMedia';
+import {MAX_FS_VALUES} from './remoteMedia';
 
 export interface ActiveSpeakerPolicyInfo {
   policy: 'active-speaker';
@@ -123,12 +123,12 @@ export class MediaRequestManager {
 
   private getDegradedClientRequests(clientRequests: ClientRequestsMap) {
     const maxFsLimits = [
-      getMaxFs('best'),
-      getMaxFs('large'),
-      getMaxFs('medium'),
-      getMaxFs('small'),
-      getMaxFs('very small'),
-      getMaxFs('thumbnail'),
+      MAX_FS_VALUES['1080p'],
+      MAX_FS_VALUES['720p'],
+      MAX_FS_VALUES['540p'],
+      MAX_FS_VALUES['360p'],
+      MAX_FS_VALUES['180p'],
+      MAX_FS_VALUES['90p'],
     ];
 
     // reduce max-fs until total macroblocks is below limit

package/src/multistream/remoteMedia.ts

@@ -19,17 +19,18 @@ export type RemoteVideoResolution =
   | 'large' // 1080p or less
   | 'best'; // highest possible resolution
 
-const MAX_FS_VALUES = {
+export const MAX_FS_VALUES = {
   '90p': 60,
   '180p': 240,
   '360p': 920,
+  '540p': 2040,
   '720p': 3600,
   '1080p': 8192,
 };
 
 /**
  * Converts pane size into h264 maxFs
- * @param {PaneSize} paneSize
+ * @param {RemoteVideoResolution} paneSize
  * @returns {number}
  */
 export function getMaxFs(paneSize: RemoteVideoResolution): number {
@@ -89,6 +90,13 @@ export class RemoteMedia extends EventsScope {
 
   public readonly id: RemoteMediaId;
 
+  /**
+   * The max frame size of the media request, used for logging and media requests.
+   * Set by setSizeHint() based on video element dimensions.
+   * When > 0, this value takes precedence over options.resolution in sendMediaRequest().
+   */
+  private maxFrameSize = 0;
+
   /**
    * Constructs RemoteMedia instance
    *
@@ -136,15 +144,34 @@ export class RemoteMedia extends EventsScope {
       fs = MAX_FS_VALUES['180p'];
     } else if (height < getThresholdHeight(360)) {
       fs = MAX_FS_VALUES['360p'];
+    } else if (height < getThresholdHeight(540)) {
+      fs = MAX_FS_VALUES['540p'];
     } else if (height <= 720) {
       fs = MAX_FS_VALUES['720p'];
     } else {
       fs = MAX_FS_VALUES['1080p'];
     }
 
+    this.maxFrameSize = fs;
     this.receiveSlot?.setMaxFs(fs);
   }
 
+  /**
+   * Get the current effective maxFs value that would be used in media requests
+   * @returns {number | undefined} The maxFs value, or undefined if no constraints
+   */
+  public getEffectiveMaxFs(): number | undefined {
+    if (this.maxFrameSize > 0) {
+      return this.maxFrameSize;
+    }
+
+    if (this.options.resolution) {
+      return getMaxFs(this.options.resolution);
+    }
+
+    return undefined;
+  }
+
   /**
    * Invalidates the remote media by clearing the reference to a receive slot and
    * cancelling the media request.
@@ -185,6 +212,9 @@ export class RemoteMedia extends EventsScope {
       throw new Error('sendMediaRequest() called on an invalidated RemoteMedia instance');
     }
 
+    // Use maxFrameSize from setSizeHint if available, otherwise fallback to options.resolution
+    const maxFs = this.getEffectiveMaxFs();
+
     this.mediaRequestId = this.mediaRequestManager.addRequest(
       {
         policyInfo: {
@@ -192,9 +222,9 @@ export class RemoteMedia extends EventsScope {
           csi,
         },
         receiveSlots: [this.receiveSlot],
-        codecInfo: this.options.resolution && {
+        codecInfo: maxFs && {
           codec: 'h264',
-          maxFs: getMaxFs(this.options.resolution),
+          maxFs,
         },
       },
       commit

package/src/multistream/remoteMediaGroup.ts

@@ -215,6 +215,9 @@ export class RemoteMediaGroup {
   private sendActiveSpeakerMediaRequest(commit: boolean) {
     this.cancelActiveSpeakerMediaRequest(false);
 
+    // Calculate the effective maxFs based on all unpinned RemoteMedia instances
+    const effectiveMaxFs = this.getEffectiveMaxFsForActiveSpeaker();
+
     this.mediaRequestId = this.mediaRequestManager.addRequest(
       {
         policyInfo: {
@@ -230,9 +233,9 @@ export class RemoteMediaGroup {
         receiveSlots: this.unpinnedRemoteMedia.map((remoteMedia) =>
           remoteMedia.getUnderlyingReceiveSlot()
         ) as ReceiveSlot[],
-        codecInfo: this.options.resolution && {
+        codecInfo: effectiveMaxFs && {
           codec: 'h264',
-          maxFs: getMaxFs(this.options.resolution),
+          maxFs: effectiveMaxFs,
         },
       },
       commit
@@ -300,4 +303,36 @@ export class RemoteMediaGroup {
       this.unpinnedRemoteMedia.includes(remoteMedia) || this.pinnedRemoteMedia.includes(remoteMedia)
     );
   }
+
+  /**
+   * Calculate the effective maxFs for the active speaker media request based on unpinned RemoteMedia instances
+   * @returns {number | undefined} The calculated maxFs value, or undefined if no constraints
+   * @private
+   */
+  private getEffectiveMaxFsForActiveSpeaker(): number | undefined {
+    // Get all effective maxFs values from unpinned RemoteMedia instances
+    const maxFsValues = this.unpinnedRemoteMedia
+      .map((remoteMedia) => remoteMedia.getEffectiveMaxFs())
+      .filter((maxFs) => maxFs !== undefined);
+
+    // Use the highest maxFs value to ensure we don't under-request resolution for any instance
+    if (maxFsValues.length > 0) {
+      return Math.max(...maxFsValues);
+    }
+
+    // Fall back to group's resolution option
+    if (this.options.resolution) {
+      return getMaxFs(this.options.resolution);
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Get the current effective maxFs that would be used for the active speaker media request
+   * @returns {number | undefined} The effective maxFs value
+   */
+  public getEffectiveMaxFs(): number | undefined {
+    return this.getEffectiveMaxFsForActiveSpeaker();
+  }
 }

package/test/unit/spec/multistream/mediaRequestManager.ts

@@ -3,7 +3,7 @@ import {MediaRequestManager} from '@webex/plugin-meetings/src/multistream/mediaR
 import {ReceiveSlot} from '@webex/plugin-meetings/src/multistream/receiveSlot';
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
-import {getMaxFs} from '@webex/plugin-meetings/src/multistream/remoteMedia';
+import {getMaxFs, MAX_FS_VALUES} from '@webex/plugin-meetings/src/multistream/remoteMedia';
 import FakeTimers from '@sinonjs/fake-timers';
 import * as InternalMediaCoreModule from '@webex/internal-media-core';
 import { expect } from 'chai';
@@ -36,12 +36,15 @@ describe('MediaRequestManager', () => {
   const CROSS_POLICY_DUPLICATION = true;
   const MAX_FPS = 3000;
   const MAX_FS_360p = 920;
+  const MAX_FS_540p = 2040;
   const MAX_FS_720p = 3600;
   const MAX_FS_1080p = 8192;
   const MAX_MBPS_360p = 27600;
+  const MAX_MBPS_540p = 61200;
   const MAX_MBPS_720p = 108000;
   const MAX_MBPS_1080p = 245760;
   const MAX_PAYLOADBITSPS_360p = 640000;
+  const MAX_PAYLOADBITSPS_540p = 880000;
   const MAX_PAYLOADBITSPS_720p = 2500000;
   const MAX_PAYLOADBITSPS_1080p = 4000000;
 
@@ -82,7 +85,14 @@ describe('MediaRequestManager', () => {
   });
 
   // helper function for adding an active speaker request
-  const addActiveSpeakerRequest = (priority, receiveSlots, maxFs, commit = false, preferLiveVideo = true, namedMediaGroups = undefined) =>
+  const addActiveSpeakerRequest = (
+    priority,
+    receiveSlots,
+    maxFs,
+    commit = false,
+    preferLiveVideo = true,
+    namedMediaGroups = undefined
+  ) =>
     mediaRequestManager.addRequest(
       {
         policyInfo: {
@@ -216,6 +226,9 @@ describe('MediaRequestManager', () => {
       },
       false
     );
+
+
+
     mediaRequestManager.addRequest(
       {
         policyInfo: {
@@ -892,15 +905,15 @@ describe('MediaRequestManager', () => {
     // request 10 "large" 1080p streams
     addActiveSpeakerRequest(255, fakeReceiveSlots.slice(0, 10), getMaxFs('large'), true);
 
-    // check that resulting requests are 10 "small" 360p streams
+    // check that resulting requests are 10 540p streams
     checkMediaRequestsSent([
       {
         policy: 'active-speaker',
         priority: 255,
         receiveSlots: fakeWcmeSlots.slice(0, 10),
-        maxPayloadBitsPerSecond: MAX_PAYLOADBITSPS_360p,
-        maxFs: getMaxFs('small'),
-        maxMbps: MAX_MBPS_360p,
+        maxPayloadBitsPerSecond: MAX_PAYLOADBITSPS_540p,
+        maxFs:  MAX_FS_VALUES['540p'],
+        maxMbps: MAX_MBPS_540p,
       },
     ]);
   });

package/test/unit/spec/multistream/remoteMedia.ts

@@ -3,7 +3,7 @@ import 'jsdom-global/register';
 import EventEmitter from 'events';
 
 import {MediaType} from '@webex/internal-media-core';
-import {RemoteMedia, RemoteMediaEvents} from '@webex/plugin-meetings/src/multistream/remoteMedia';
+import {RemoteMedia, RemoteMediaEvents, RemoteVideoResolution} from '@webex/plugin-meetings/src/multistream/remoteMedia';
 import {ReceiveSlotEvents} from '@webex/plugin-meetings/src/multistream/receiveSlot';
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
@@ -257,7 +257,9 @@ describe('RemoteMedia', () => {
         {height: 198, fs: 920}, // 360p
         {height: 360, fs: 920},
         {height: 395, fs: 920},
-        {height: 396, fs: 3600}, // 720p
+        {height: 396, fs: 2040}, // 540p
+        {height: 540, fs: 2040},
+        {height: 610, fs: 3600}, // 720p
         {height: 720, fs: 3600},
         {height: 721, fs: 8192}, // 1080p
         {height: 1080, fs: 8192},
@@ -271,4 +273,66 @@ describe('RemoteMedia', () => {
       }
     );
   });
+
+  describe('getEffectiveMaxFs()', () => {
+    it('returns maxFrameSize when it is greater than 0', () => {
+      remoteMedia.setSizeHint(960, 540);
+
+      const result = remoteMedia.getEffectiveMaxFs();
+
+      assert.strictEqual(result, 2040);
+    });
+
+    it('returns getMaxFs result when maxFrameSize is 0 and resolution is provided', () => {
+      remoteMedia.setSizeHint(0, 0);
+
+      // remoteMedia was created with {resolution: 'medium'} in beforeEach
+
+      const result = remoteMedia.getEffectiveMaxFs();
+      
+      // 'medium' resolution should map to 720p which is 3600
+      assert.strictEqual(result, 3600);
+    });
+
+    it('returns undefined when maxFrameSize is 0 and no resolution is provided', () => {
+      remoteMedia.setSizeHint(0, 0);
+
+      // Create a new RemoteMedia without resolution option
+      const remoteMediaWithoutResolution = new RemoteMedia(fakeReceiveSlot, fakeMediaRequestManager);
+      
+      const result = remoteMediaWithoutResolution.getEffectiveMaxFs();
+      
+      assert.strictEqual(result, undefined);
+    });
+
+    it('prioritizes maxFrameSize over resolution option', () => {
+      remoteMedia.setSizeHint(640, 360);
+      // remoteMedia was created with {resolution: 'medium'} in beforeEach
+
+      const result = remoteMedia.getEffectiveMaxFs();
+      
+      // Should return maxFrameSize (500) instead of resolution-based value (3600)
+      assert.strictEqual(result, 920);
+    });
+
+    it('works correctly with different resolution options', () => {
+      const testCases: Array<{ resolution: RemoteVideoResolution; expected: number }> = [
+        { resolution: 'thumbnail', expected: 60 },
+        { resolution: 'very small', expected: 240 },
+        { resolution: 'small', expected: 920 },
+        { resolution: 'medium', expected: 3600 },
+        { resolution: 'large', expected: 8192 },
+        { resolution: 'best', expected: 8192 },
+      ];
+
+      testCases.forEach(({ resolution, expected }) => {
+        const testRemoteMedia = new RemoteMedia(fakeReceiveSlot, fakeMediaRequestManager, { resolution });
+        testRemoteMedia.setSizeHint(0, 0); // Ensure maxFrameSize doesn't interfere
+
+        const result = testRemoteMedia.getEffectiveMaxFs();
+        
+        assert.strictEqual(result, expected, `Failed for resolution: ${resolution}`);
+      });
+    });
+  });
 });