@webex/plugin-meetings 2.31.3 → 2.32.0

package/src/meeting/index.js

@@ -125,6 +125,7 @@ export const MEDIA_UPDATE_TYPE = {
   * @property {String} audio.deviceId
   * @property {Object} video
   * @property {String} video.deviceId
+  * @property {String} video.localVideoQuality // [240p, 360p, 480p, 720p, 1080p]
   */
 
 /**
@@ -2742,6 +2743,15 @@ export default class Meeting extends StatelessWebexPlugin {
         aspectRatio, frameRate, height, width, deviceId
       } = videoTrack.getSettings();
 
+      const {localQualityLevel} = this.mediaProperties;
+
+      if (Number(localQualityLevel.slice(0, -1)) > height) {
+        LoggerProxy.logger.error(`Meeting:index#setLocalVideoTrack --> Local video quality of ${localQualityLevel} not supported,
+         downscaling to highest possible resolution of ${height}p`);
+
+        this.mediaProperties.setLocalQualityLevel(`${height}p`);
+      }
+
       this.mediaProperties.setLocalVideoTrack(videoTrack);
       if (this.video) this.video.applyClientStateLocally(this);
 
@@ -4004,6 +4014,9 @@ export default class Meeting extends StatelessWebexPlugin {
         LoggerProxy.logger.warn('Meeting:index#getMediaStreams --> Please use `meeting.shareScreen()` to manually start the screen share after successfully joining the meeting');
       }
 
+      if (!audioVideo.video) {
+        audioVideo = {...audioVideo, video: {...audioVideo.video, ...VIDEO_RESOLUTIONS[this.mediaProperties.localQualityLevel].video}};
+      }
       // extract deviceId if exists otherwise default to null.
       const {deviceId: preferredVideoDevice} = (audioVideo && audioVideo.video || {deviceId: null});
       const lastVideoDeviceId = this.mediaProperties.getVideoDeviceId();
@@ -5342,7 +5355,7 @@ export default class Meeting extends StatelessWebexPlugin {
   /**
    * Sets the quality of the local video stream
    * @param {String} level {LOW|MEDIUM|HIGH}
-   * @returns {Promise}
+   * @returns {Promise<MediaStream>} localStream
    */
   setLocalVideoQuality(level) {
     LoggerProxy.logger.log(`Meeting:index#setLocalVideoQuality --> Setting quality to ${level}`);
@@ -5371,13 +5384,22 @@ export default class Meeting extends StatelessWebexPlugin {
       sendShare: this.mediaProperties.mediaDirection.sendShare
     };
 
+    // When changing local video quality level
+    // Need to stop current track first as chrome doesn't support resolution upscaling(for eg. changing 480p to 720p)
+    // Without feeding it a new track
+    // open bug link: https://bugs.chromium.org/p/chromium/issues/detail?id=943469
+    if (isBrowser('chrome') && this.mediaProperties.videoTrack) Media.stopTracks(this.mediaProperties.videoTrack);
+
     return this.getMediaStreams(mediaDirection, VIDEO_RESOLUTIONS[level])
-      .then(([localStream]) =>
-        this.updateVideo({
+      .then(async ([localStream]) => {
+        await this.updateVideo({
           sendVideo: true,
           receiveVideo: true,
           stream: localStream
-        }));
+        });
+
+        return localStream;
+      });
   }
 
   /**
@@ -5410,9 +5432,10 @@ export default class Meeting extends StatelessWebexPlugin {
   }
 
   /**
-   * Sets the quality level of all meeting media (incoming/outgoing)
+   * This is deprecated, please use setLocalVideoQuality for setting local and setRemoteQualityLevel for remote
    * @param {String} level {LOW|MEDIUM|HIGH}
    * @returns {Promise}
+   * @deprecated After FHD support
    */
   setMeetingQuality(level) {
     LoggerProxy.logger.log(`Meeting:index#setMeetingQuality --> Setting quality to ${level}`);

package/src/peer-connection-manager/index.js

@@ -20,7 +20,7 @@ import {
   PEER_CONNECTION_STATE,
   OFFER,
   QUALITY_LEVELS,
-  MAX_FRAMESIZES
+  REMOTE_VIDEO_CONSTRAINTS
 } from '../constants';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import {error, eventType} from '../metrics/config';
@@ -70,18 +70,16 @@ const insertBandwidthLimit = (sdpLines, index) => {
  * @param {String} [level=QUALITY_LEVELS.HIGH] quality level for max-fs
  * @returns {String}
  */
-const setMaxFs = (sdp, level = QUALITY_LEVELS.HIGH) => {
-  if (!MAX_FRAMESIZES[level]) {
-    throw new ParameterError(`setMaxFs: unable to set max framesize, value for level "${level}" is not defined`);
+const setRemoteVideoConstraints = (sdp, level = QUALITY_LEVELS.HIGH) => {
+  const maxFs = REMOTE_VIDEO_CONSTRAINTS.MAX_FS[level];
+
+  if (!maxFs) {
+    throw new ParameterError(`setRemoteVideoConstraints: unable to set max framesize, value for level "${level}" is not defined`);
   }
-  // eslint-disable-next-line no-warning-comments
-  // TODO convert with sdp parser, no munging
-  let replaceSdp = sdp;
-  const maxFsLine = `${SDP.MAX_FS}${MAX_FRAMESIZES[level]}`;
 
-  replaceSdp = replaceSdp.replace(/(\na=fmtp:(\d+).*profile-level-id=.*)/gi, `$1;${maxFsLine}`);
+  const modifiedSdp = PeerConnectionUtils.adjustH264Profile(sdp, maxFs);
 
-  return replaceSdp;
+  return modifiedSdp;
 };
 
 
@@ -188,8 +186,8 @@ pc.iceCandidate = (peerConnection, {remoteQualityLevel}) =>
       const miliseconds = parseInt(Math.abs(Date.now() - now), 4);
 
       peerConnection.sdp = limitBandwidth(peerConnection.localDescription.sdp);
-      peerConnection.sdp = setMaxFs(peerConnection.sdp, remoteQualityLevel);
       peerConnection.sdp = PeerConnectionUtils.convertCLineToIpv4(peerConnection.sdp);
+      peerConnection.sdp = setRemoteVideoConstraints(peerConnection.sdp, remoteQualityLevel);
 
       const invalidSdpPresent = isSdpInvalid(peerConnection.sdp);
 
@@ -540,8 +538,9 @@ pc.createAnswer = (params, {meetingId, remoteQualityLevel}) => {
     .then(() => pc.iceCandidate(peerConnection, {remoteQualityLevel}))
     .then(() => {
       peerConnection.sdp = limitBandwidth(peerConnection.localDescription.sdp);
-      peerConnection.sdp = setMaxFs(peerConnection.sdp, remoteQualityLevel);
       peerConnection.sdp = PeerConnectionUtils.convertCLineToIpv4(peerConnection.sdp);
+      peerConnection.sdp = setRemoteVideoConstraints(peerConnection.sdp, remoteQualityLevel);
+
       if (!checkH264Support(peerConnection.sdp)) {
         throw new MediaError('openH264 is downloading please Wait. Upload logs if not working on second try');
       }

package/src/peer-connection-manager/util.ts

@@ -0,0 +1,117 @@
+import { parse } from '@webex/ts-sdp';
+
+interface IPeerConnectionUtils {
+  convertCLineToIpv4: (sdp: string) => string;
+  adjustH264Profile: (sdp: string, maxFsValue: number) => string;
+}
+
+const PeerConnectionUtils = {} as IPeerConnectionUtils;
+
+// max-fs values for all H264 profile levels
+const maxFsForProfileLevel = {
+  10: 99,
+  11: 396,
+  12: 396,
+  13: 396,
+  20: 396,
+  21: 792,
+  22: 1620,
+  30: 1620,
+  31: 3600,
+  32: 5120,
+  40: 8192,
+  41: 8192,
+  42: 8704,
+  50: 22080,
+  51: 36864,
+  52: 36864,
+  60: 139264,
+  61: 139264,
+  62: 139264,
+};
+
+const framesPerSecond = 30;
+
+/**
+ * Convert C line to IPv4
+ * @param {string} sdp
+ * @returns {string}
+ */
+PeerConnectionUtils.convertCLineToIpv4 = (sdp: string) => {
+  let replaceSdp = sdp;
+
+  // TODO: remove this once linus supports Ipv6 c line.currently linus rejects SDP with c line having ipv6 candidates we are
+  // mocking ipv6 to ipv4 candidates
+  // https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-299232
+  replaceSdp = replaceSdp.replace(/c=IN IP6 .*/gi, 'c=IN IP4 0.0.0.0');
+
+  return replaceSdp;
+};
+
+/**
+ * estimate profile levels for max-fs & max-mbps values
+ * @param {string} sdp
+ * @param {number} maxFsValue
+ * @returns {string}
+ */
+PeerConnectionUtils.adjustH264Profile = (sdp: string, maxFsValue: number) => {
+  // converting with ts-sdp parser, no munging
+  const parsedSdp = parse(sdp);
+
+  parsedSdp.avMedia.forEach((media) => {
+    if (media.type === 'video') {
+      media.codecs.forEach((codec) => {
+        if (codec.name?.toUpperCase() === 'H264') {
+          // there should really be just 1 fmtp line, but just in case, we process all of them
+          codec.fmtParams = codec.fmtParams.map((fmtp) => {
+            const parsedRegex = fmtp.match(/(.*)profile-level-id=(\w{4})(\w{2})(.*)/);
+
+            if (parsedRegex && parsedRegex.length === 5) {
+              const stuffBeforeProfileLevelId = parsedRegex[1];
+              const profile = parsedRegex[2].toLowerCase();
+              const levelId = parseInt(parsedRegex[3], 16);
+              const stuffAfterProfileLevelId = parsedRegex[4];
+
+              if (!maxFsForProfileLevel[levelId]) {
+                throw new Error(
+                  `found unsupported h264 profile level id value in the SDP: ${levelId}`
+                );
+              }
+
+              if (maxFsForProfileLevel[levelId] === maxFsValue) {
+                // profile level already matches our desired max-fs value, so we don't need to do anything
+                return fmtp;
+              }
+              if (maxFsForProfileLevel[levelId] < maxFsValue) {
+                // profile level has too low max-fs, so we need to override it (this is upgrading)
+                return `${fmtp};max-fs=${maxFsValue};max-mbps=${maxFsValue * framesPerSecond}`;
+              }
+
+              // profile level has too high max-fs value, so we need to use a lower level
+
+              // find highest level that has the matching maxFs
+              const newLevelId = Object.keys(maxFsForProfileLevel)
+                .reverse()
+                .find((key) => maxFsForProfileLevel[key] === maxFsValue);
+
+              if (newLevelId) {
+                // Object.keys returns keys as strings, so we need to parse it to an int again and then convert to hex
+                const newLevelIdHex = parseInt(newLevelId, 10).toString(16);
+
+                return `${stuffBeforeProfileLevelId}profile-level-id=${profile}${newLevelIdHex};max-mbps=${maxFsValue * framesPerSecond}${stuffAfterProfileLevelId}`;
+              }
+
+              throw new Error(`unsupported maxFsValue: ${maxFsValue}`);
+            }
+
+            return fmtp;
+          });
+        }
+      });
+    }
+  });
+
+  return parsedSdp.toString();
+};
+
+export default PeerConnectionUtils;

package/test/unit/spec/meeting/index.js

@@ -671,7 +671,7 @@ describe('plugin-meetings', () => {
           const audioVideoSettings = {};
 
           sinon.stub(meeting.mediaProperties, 'videoDeviceId').value(videoDevice);
-
+          sinon.stub(meeting.mediaProperties, 'localQualityLevel').value('480p');
           await meeting.getMediaStreams(mediaDirection, audioVideoSettings);
 
           assert.calledWith(Media.getUserMedia, {
@@ -680,6 +680,8 @@ describe('plugin-meetings', () => {
           },
           {
             video: {
+              width: {max: 640, ideal: 640},
+              height: {max: 480, ideal: 480},
               deviceId: videoDevice
             }
           });
@@ -701,6 +703,30 @@ describe('plugin-meetings', () => {
           assert.calledWith(meeting.mediaProperties.setVideoDeviceId, newVideoDevice);
         });
 
+        it('uses the passed custom video resolution', async () => {
+          const mediaDirection = {sendAudio: true, sendVideo: true, sendShare: false};
+          const customAudioVideoSettings = {
+            video: {
+              width: {
+                max: 400,
+                ideal: 400
+              },
+              height: {
+                max: 200,
+                ideal: 200
+              }
+            }
+          };
+
+          sinon.stub(meeting.mediaProperties, 'localQualityLevel').value('200p');
+          await meeting.getMediaStreams(mediaDirection, customAudioVideoSettings);
+
+          assert.calledWith(Media.getUserMedia, {
+            ...mediaDirection,
+            isSharing: false
+          },
+          customAudioVideoSettings);
+        });
         it('should not access camera if sendVideo is false ', async () => {
           await meeting.getMediaStreams({sendAudio: true, sendVideo: false});
 
@@ -2155,11 +2181,19 @@ describe('plugin-meetings', () => {
       describe('#setLocalVideoQuality', () => {
         let mediaDirection;
 
+        const fakeTrack = {getSettings: () => ({height: 720})};
+        const USER_AGENT_CHROME_MAC =
+        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) ' +
+        'AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.85 Safari/537.36';
+
         beforeEach(() => {
           mediaDirection = {sendAudio: true, sendVideo: true, sendShare: false};
           meeting.getMediaStreams = sinon.stub().returns(Promise.resolve([]));
-          meeting.updateVideo = sinon.stub().returns(Promise.resolve());
           meeting.mediaProperties.mediaDirection = mediaDirection;
+          meeting.canUpdateMedia = sinon.stub().returns(true);
+          MeetingUtil.validateOptions = sinon.stub().returns(Promise.resolve());
+          MeetingUtil.updateTransceiver = sinon.stub().returns(Promise.resolve());
+          sinon.stub(MeetingUtil, 'getTrack').returns({videoTrack: fakeTrack});
         });
 
         it('should have #setLocalVideoQuality', () => {
@@ -2167,15 +2201,35 @@ describe('plugin-meetings', () => {
         });
 
         it('should call getMediaStreams with the proper level', () => meeting.setLocalVideoQuality(CONSTANTS.QUALITY_LEVELS.LOW).then(() => {
+          delete mediaDirection.receiveVideo;
           assert.calledWith(meeting.getMediaStreams,
             mediaDirection,
             CONSTANTS.VIDEO_RESOLUTIONS[CONSTANTS.QUALITY_LEVELS.LOW]);
         }));
 
+        it('when browser is chrome then it should stop previous video track', () => {
+          meeting.mediaProperties.videoTrack = fakeTrack;
+          assert.equal(
+            BrowserDetection(USER_AGENT_CHROME_MAC).getBrowserName(),
+            'Chrome'
+          );
+          meeting.setLocalVideoQuality(CONSTANTS.QUALITY_LEVELS.LOW)
+            .then(() => {
+              assert.calledWith(Media.stopTracks, fakeTrack);
+            });
+        });
+
         it('should set mediaProperty with the proper level', () => meeting.setLocalVideoQuality(CONSTANTS.QUALITY_LEVELS.LOW).then(() => {
           assert.equal(meeting.mediaProperties.localQualityLevel, CONSTANTS.QUALITY_LEVELS.LOW);
         }));
 
+        it('when device does not support 1080p then it should set localQualityLevel with highest possible resolution', () => {
+          meeting.setLocalVideoQuality(CONSTANTS.QUALITY_LEVELS['1080p'])
+            .then(() => {
+              assert.equal(meeting.mediaProperties.localQualityLevel, CONSTANTS.QUALITY_LEVELS['720p']);
+            });
+        });
+
         it('should error if set to a invalid level', () => {
           assert.isRejected(meeting.setLocalVideoQuality('invalid'));
         });
@@ -2217,54 +2271,6 @@ describe('plugin-meetings', () => {
         });
       });
 
-      describe('#setMeetingQuality', () => {
-        let mediaDirection;
-
-        beforeEach(() => {
-          mediaDirection = {
-            receiveAudio: true, receiveVideo: true, receiveShare: false, sendVideo: true
-          };
-          meeting.setRemoteQualityLevel = sinon.stub().returns(Promise.resolve());
-          meeting.setLocalVideoQuality = sinon.stub().returns(Promise.resolve());
-          meeting.mediaProperties.mediaDirection = mediaDirection;
-        });
-
-        it('should have #setMeetingQuality', () => {
-          assert.exists(meeting.setMeetingQuality);
-        });
-
-        it('should call setRemoteQualityLevel', () => meeting.setMeetingQuality(CONSTANTS.QUALITY_LEVELS.LOW).then(() => {
-          assert.calledOnce(meeting.setRemoteQualityLevel);
-        }));
-
-        it('should not call setRemoteQualityLevel when receiveVideo and receiveAudio are false', () => {
-          mediaDirection.receiveAudio = false;
-          mediaDirection.receiveVideo = false;
-          meeting.mediaProperties.mediaDirection = mediaDirection;
-
-          return meeting.setMeetingQuality(CONSTANTS.QUALITY_LEVELS.LOW).then(() => {
-            assert.notCalled(meeting.setRemoteQualityLevel);
-          });
-        });
-
-        it('should call setLocalVideoQuality', () => meeting.setMeetingQuality(CONSTANTS.QUALITY_LEVELS.LOW).then(() => {
-          assert.calledOnce(meeting.setLocalVideoQuality);
-        }));
-
-        it('should not call setLocalVideoQuality when sendVideo is false', () => {
-          mediaDirection.sendVideo = false;
-          meeting.mediaProperties.mediaDirection = mediaDirection;
-
-          return meeting.setMeetingQuality(CONSTANTS.QUALITY_LEVELS.LOW).then(() => {
-            assert.notCalled(meeting.setLocalVideoQuality);
-          });
-        });
-
-        it('should error if set to a invalid level', () => {
-          assert.isRejected(meeting.setMeetingQuality('invalid'));
-        });
-      });
-
       describe('#usePhoneAudio', () => {
         beforeEach(() => {
           meeting.meetingRequest.dialIn = sinon.stub().returns(Promise.resolve({body: {locus: 'testData'}}));

package/test/unit/spec/peerconnection-manager/utils.js

@@ -1,19 +1,24 @@
-
 import {assert} from '@webex/test-helper-chai';
 import PeerConnectionUtils from '@webex/plugin-meetings/src/peer-connection-manager/util';
 
+import {
+  SDP_MULTIPLE_VIDEO_CODECS,
+  SDP_MULTIPLE_VIDEO_CODECS_WITH_LOWERED_H264_PROFILE_LEVEL,
+  SDP_MULTIPLE_VIDEO_CODECS_WITH_MAX_FS
+} from './utils.test-fixtures';
+
 describe('Peerconnection Manager', () => {
   describe('Utils', () => {
     describe('convertCLineToIpv4', () => {
       it('changes ipv6 to ipv4 default', () => {
         const localSdp = 'v=0\r\n' +
-        'm=video 5004 UDP/TLS/RTP/SAVPF 102 127 97 99\r\n' +
-        'c=IN IP6 2607:fb90:d27c:b314:211a:32dd:c47f:ffe\r\n' +
-        'a=rtpmap:127 H264/90000\r\n';
+          'm=video 5004 UDP/TLS/RTP/SAVPF 102 127 97 99\r\n' +
+          'c=IN IP6 2607:fb90:d27c:b314:211a:32dd:c47f:ffe\r\n' +
+          'a=rtpmap:127 H264/90000\r\n';
         const resultSdp = 'v=0\r\n' +
-        'm=video 5004 UDP/TLS/RTP/SAVPF 102 127 97 99\r\n' +
-        'c=IN IP4 0.0.0.0\r\n' +
-        'a=rtpmap:127 H264/90000\r\n';
+          'm=video 5004 UDP/TLS/RTP/SAVPF 102 127 97 99\r\n' +
+          'c=IN IP4 0.0.0.0\r\n' +
+          'a=rtpmap:127 H264/90000\r\n';
 
 
         const temp = PeerConnectionUtils.convertCLineToIpv4(localSdp);
@@ -21,5 +26,23 @@ describe('Peerconnection Manager', () => {
         assert.equal(temp, resultSdp);
       });
     });
+
+    describe('adjustH264Profile', () => {
+      it('appends max-fs and max-mbps to h264 fmtp lines when h264MaxFs value is higher than the value from the profile', () => {
+        const modifiedSdp = PeerConnectionUtils.adjustH264Profile(SDP_MULTIPLE_VIDEO_CODECS, 8192);
+
+        assert.equal(modifiedSdp, SDP_MULTIPLE_VIDEO_CODECS_WITH_MAX_FS);
+      });
+      it('keeps fmtp lines the same when h264MaxFs value matches the value from the profile', () => {
+        const modifiedSdp = PeerConnectionUtils.adjustH264Profile(SDP_MULTIPLE_VIDEO_CODECS, 3600);
+
+        assert.equal(modifiedSdp, SDP_MULTIPLE_VIDEO_CODECS);
+      });
+      it('changes the profile level in h264 fmtp lines when h264MaxFs value is lower than the value from the profile', () => {
+        const modifiedSdp = PeerConnectionUtils.adjustH264Profile(SDP_MULTIPLE_VIDEO_CODECS, 1620);
+
+        assert.equal(modifiedSdp, SDP_MULTIPLE_VIDEO_CODECS_WITH_LOWERED_H264_PROFILE_LEVEL);
+      });
+    });
   });
 });