@webex/plugin-meetings 2.59.8 → 2.60.0-next.2

package/src/statsAnalyzer/mqaUtil.ts

@@ -1,30 +1,41 @@
-/* eslint-disable prefer-destructuring */
+/* eslint-disable no-param-reassign, prefer-destructuring */
 
 import {mean, max} from 'lodash';
 
 import {STATS} from '../constants';
 
-export const getAudioReceiverMqa = ({audioReceiver, statsResults, lastMqaDataSent}) => {
-  const mediaType = STATS.AUDIO_CORRELATE;
+export const getAudioReceiverMqa = ({audioReceiver, statsResults, lastMqaDataSent, mediaType}) => {
   const sendrecvType = STATS.RECEIVE_DIRECTION;
 
+  const lastPacketsReceived = lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsReceived || 0;
+  const lastPacketsLost = lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsLost || 0;
+  const lastPacketsDecoded = lastMqaDataSent[mediaType]?.[sendrecvType].totalSamplesDecoded || 0;
+  const lastSamplesReceived = lastMqaDataSent[mediaType]?.[sendrecvType].totalSamplesReceived || 0;
+  const lastConcealedSamples = lastMqaDataSent[mediaType]?.[sendrecvType].concealedSamples || 0;
+  const lastBytesReceived = lastMqaDataSent[mediaType]?.[sendrecvType].totalBytesReceived || 0;
+  const lastFecPacketsReceived = lastMqaDataSent[mediaType]?.[sendrecvType].fecPacketsReceived || 0;
+  const lastFecPacketsDiscarded =
+    lastMqaDataSent[mediaType]?.[sendrecvType].fecPacketsDiscarded || 0;
+
+  const {csi} = statsResults[mediaType];
+  if (csi && !audioReceiver.streams[0].common.csi.includes(csi)) {
+    audioReceiver.streams[0].common.csi.push(csi);
+  }
+
   audioReceiver.common.common.direction = statsResults[mediaType].direction;
-  audioReceiver.common.transportType = statsResults.connectionType.remote.transport[0];
+  audioReceiver.common.transportType = statsResults.connectionType.local.transport;
+
   // add rtpPacket info inside common as also for call analyzer
   audioReceiver.common.rtpPackets =
-    statsResults[mediaType][sendrecvType].totalPacketsReceived -
-      lastMqaDataSent[mediaType][sendrecvType].totalPacketsReceived || 0;
+    statsResults[mediaType][sendrecvType].totalPacketsReceived - lastPacketsReceived || 0;
   // Hop by hop are numbers and not percentage so we compare on what we sent the last min
   // collect the packets received for the last min
   audioReceiver.streams[0].common.rtpPackets = audioReceiver.common.rtpPackets;
   audioReceiver.common.mediaHopByHopLost =
-    statsResults[mediaType][sendrecvType].totalPacketsLost -
-      lastMqaDataSent[mediaType][sendrecvType].totalPacketsLost || 0;
+    statsResults[mediaType][sendrecvType].totalPacketsLost - lastPacketsLost || 0;
   audioReceiver.common.rtpHopByHopLost =
-    statsResults[mediaType][sendrecvType].totalPacketsLost -
-      lastMqaDataSent[mediaType][sendrecvType].totalPacketsLost || 0;
+    statsResults[mediaType][sendrecvType].totalPacketsLost - lastPacketsLost || 0;
 
-  // @ts-ignore
   audioReceiver.streams[0].common.maxRtpJitter =
     // @ts-ignore
     max(statsResults[mediaType][sendrecvType].meanRtpJitter) * 1000 || 0;
@@ -35,43 +46,45 @@ export const getAudioReceiverMqa = ({audioReceiver, statsResults, lastMqaDataSen
   // Fec packets do come in as part of the FEC only for audio
   const fecRecovered =
     statsResults[mediaType][sendrecvType].fecPacketsReceived -
-    lastMqaDataSent[mediaType][sendrecvType].fecPacketsReceived -
-    (statsResults[mediaType][sendrecvType].fecPacketsDiscarded -
-      lastMqaDataSent[mediaType][sendrecvType].fecPacketsDiscarded);
+    lastFecPacketsReceived -
+    (statsResults[mediaType][sendrecvType].fecPacketsDiscarded - lastFecPacketsDiscarded);
 
   audioReceiver.streams[0].common.rtpEndToEndLost =
-    statsResults[mediaType][sendrecvType].totalPacketsLost -
-      lastMqaDataSent[mediaType][sendrecvType].totalPacketsLost -
-      fecRecovered || 0;
+    statsResults[mediaType][sendrecvType].totalPacketsLost - lastPacketsLost - fecRecovered || 0;
 
   audioReceiver.streams[0].common.framesDropped =
-    statsResults[mediaType][sendrecvType].totalSamplesDecoded -
-      lastMqaDataSent[mediaType][sendrecvType].totalSamplesDecoded || 0;
+    statsResults[mediaType][sendrecvType].totalSamplesDecoded - lastPacketsDecoded || 0;
   audioReceiver.streams[0].common.renderedFrameRate =
     (audioReceiver.streams[0].common.framesDropped * 100) / 60 || 0;
+
   audioReceiver.streams[0].common.framesReceived =
-    statsResults[mediaType][sendrecvType].totalSamplesReceived -
-      lastMqaDataSent[mediaType][sendrecvType].totalSamplesReceived || 0;
+    statsResults[mediaType][sendrecvType].totalSamplesReceived - lastSamplesReceived || 0;
   audioReceiver.streams[0].common.concealedFrames =
-    statsResults[mediaType][sendrecvType].concealedSamples -
-      lastMqaDataSent[mediaType][sendrecvType].concealedSamples || 0;
+    statsResults[mediaType][sendrecvType].concealedSamples - lastConcealedSamples || 0;
   audioReceiver.streams[0].common.receivedBitrate =
-    ((statsResults[mediaType][sendrecvType].totalBytesReceived -
-      lastMqaDataSent[mediaType][sendrecvType].totalBytesReceived) *
-      8) /
-      60 || 0;
+    ((statsResults[mediaType][sendrecvType].totalBytesReceived - lastBytesReceived) * 8) / 60 || 0;
 
   audioReceiver.common.rtpBitrate = audioReceiver.streams[0].common.receivedBitrate;
 };
 
-export const getAudioSenderMqa = ({audioSender, statsResults, lastMqaDataSent}) => {
-  const mediaType = STATS.AUDIO_CORRELATE;
+export const getAudioSenderMqa = ({audioSender, statsResults, lastMqaDataSent, mediaType}) => {
   const sendrecvType = STATS.SEND_DIRECTION;
 
+  const lastPacketsSent = lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsSent || 0;
+  const lastPacketsLost =
+    lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsLostOnReceiver || 0;
+  const lastBytesSent = lastMqaDataSent[mediaType]?.[sendrecvType].totalBytesSent || 0;
+  const lastFramesEncoded = lastMqaDataSent[mediaType]?.[sendrecvType].totalKeyFramesEncoded || 0;
+  const lastFirCount = lastMqaDataSent[mediaType]?.[sendrecvType].totalFirCount || 0;
+
+  const {csi} = statsResults[mediaType];
+  if (csi && !audioSender.streams[0].common.csi.includes(csi)) {
+    audioSender.streams[0].common.csi.push(csi);
+  }
+
   audioSender.common.common.direction = statsResults[mediaType].direction;
-  audioSender.common.transportType = statsResults.connectionType.local.transport[0];
+  audioSender.common.transportType = statsResults.connectionType.local.transport;
 
-  // @ts-ignore
   audioSender.common.maxRemoteJitter =
     // @ts-ignore
     max(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
@@ -79,8 +92,7 @@ export const getAudioSenderMqa = ({audioSender, statsResults, lastMqaDataSent})
     mean(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
 
   audioSender.common.rtpPackets =
-    statsResults[mediaType][sendrecvType].totalPacketsSent -
-      lastMqaDataSent[mediaType][sendrecvType].totalPacketsSent || 0;
+    statsResults[mediaType][sendrecvType].totalPacketsSent - lastPacketsSent || 0;
   audioSender.streams[0].common.rtpPackets = audioSender.common.rtpPackets;
   // From candidate-pair
   audioSender.common.availableBitrate =
@@ -88,15 +100,13 @@ export const getAudioSenderMqa = ({audioSender, statsResults, lastMqaDataSent})
   // Calculate based on how much packets lost of received compated to how to the client sent
 
   const totalpacketsLostForaMin =
-    statsResults[mediaType][sendrecvType].totalPacketsLostOnReceiver -
-    lastMqaDataSent[mediaType][sendrecvType].totalPacketsLostOnReceiver;
+    statsResults[mediaType][sendrecvType].totalPacketsLostOnReceiver - lastPacketsLost;
 
   audioSender.common.remoteLossRate =
     totalpacketsLostForaMin > 0
       ? (totalpacketsLostForaMin * 100) / audioSender.common.rtpPackets
       : 0; // This is the packets sent with in last min || 0;
 
-  // @ts-ignore
   audioSender.common.maxRoundTripTime =
     // @ts-ignore
     max(statsResults[mediaType][sendrecvType].meanRoundTripTime) * 1000 || 0;
@@ -105,9 +115,7 @@ export const getAudioSenderMqa = ({audioSender, statsResults, lastMqaDataSent})
   audioSender.common.roundTripTime = audioSender.common.maxRoundTripTime;
 
   // Calculate the outgoing bitrate
-  const totalBytesSentInaMin =
-    statsResults[mediaType][sendrecvType].totalBytesSent -
-    lastMqaDataSent[mediaType][sendrecvType].totalBytesSent;
+  const totalBytesSentInaMin = statsResults[mediaType][sendrecvType].totalBytesSent - lastBytesSent;
 
   audioSender.streams[0].common.transmittedBitrate = totalBytesSentInaMin
     ? (totalBytesSentInaMin * 8) / 60
@@ -115,33 +123,41 @@ export const getAudioSenderMqa = ({audioSender, statsResults, lastMqaDataSent})
   audioSender.common.rtpBitrate = audioSender.streams[0].common.transmittedBitrate;
 
   audioSender.streams[0].transmittedKeyFrames =
-    statsResults[mediaType][sendrecvType].totalKeyFramesEncoded -
-      lastMqaDataSent[mediaType][sendrecvType].totalKeyFramesEncoded || 0;
+    statsResults[mediaType][sendrecvType].totalKeyFramesEncoded - lastFramesEncoded || 0;
   audioSender.streams[0].requestedKeyFrames =
-    statsResults[mediaType][sendrecvType].totalFirCount -
-      lastMqaDataSent[mediaType][sendrecvType].totalFirCount || 0;
+    statsResults[mediaType][sendrecvType].totalFirCount - lastFirCount || 0;
 };
 
-export const getVideoReceiverMqa = ({
-  videoReceiver,
-  statsResults,
-  lastMqaDataSent,
-  isShareStream = false,
-}) => {
-  const mediaType = isShareStream ? STATS.SHARE_CORRELATE : STATS.VIDEO_CORRELATE;
+export const getVideoReceiverMqa = ({videoReceiver, statsResults, lastMqaDataSent, mediaType}) => {
   const sendrecvType = STATS.RECEIVE_DIRECTION;
 
+  const lastPacketsReceived = lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsReceived || 0;
+  const lastPacketsLost = lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsLost || 0;
+  const lastBytesReceived = lastMqaDataSent[mediaType]?.[sendrecvType].totalBytesReceived || 0;
+  const lastFramesReceived =
+    lastMqaDataSent.resolutions[mediaType]?.[sendrecvType].framesReceived || 0;
+  const lastFramesDecoded =
+    lastMqaDataSent.resolutions[mediaType]?.[sendrecvType].framesDecoded || 0;
+  const lastFramesDropped =
+    lastMqaDataSent.resolutions[mediaType]?.[sendrecvType].framesDropped || 0;
+  const lastKeyFramesDecoded = lastMqaDataSent[mediaType]?.[sendrecvType].keyFramesDecoded || 0;
+  const lastPliCount = lastMqaDataSent[mediaType]?.[sendrecvType].totalPliCount || 0;
+
+  const {csi} = statsResults[mediaType];
+  if (csi && !videoReceiver.streams[0].common.csi.includes(csi)) {
+    videoReceiver.streams[0].common.csi.push(csi);
+  }
+
   videoReceiver.common.common.direction = statsResults[mediaType].direction;
-  videoReceiver.common.transportType = statsResults.connectionType.remote.transport[0];
+  videoReceiver.common.transportType = statsResults.connectionType.local.transport;
+
   // collect the packets received for the last min
   videoReceiver.common.rtpPackets =
-    statsResults[mediaType][sendrecvType].totalPacketsReceived -
-      lastMqaDataSent[mediaType][sendrecvType].totalPacketsReceived || 0;
+    statsResults[mediaType][sendrecvType].totalPacketsReceived - lastPacketsReceived || 0;
   videoReceiver.streams[0].common.rtpPackets = videoReceiver.common.rtpPackets;
 
   const totalPacketLoss =
-    statsResults[mediaType][sendrecvType].totalPacketsLost -
-      lastMqaDataSent[mediaType][sendrecvType].totalPacketsLost || 0;
+    statsResults[mediaType][sendrecvType].totalPacketsLost - lastPacketsLost || 0;
 
   // Hope by hop are numbers and not percentage so we compare on what we sent the last min
   // this is including packet lost
@@ -153,7 +169,6 @@ export const getVideoReceiverMqa = ({
 
   // calculate this values
 
-  // @ts-ignore
   videoReceiver.common.maxRemoteJitter =
     // @ts-ignore
     max(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
@@ -161,12 +176,11 @@ export const getVideoReceiverMqa = ({
     mean(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
 
   videoReceiver.streams[0].common.rtpJitter = videoReceiver.common.maxRemoteJitter;
-  // videoReceiver.streams[0].common.rtpJitter = (statsResults.resolutions[mediaType][sendrecvType].jitterBufferDelay - lastMqaDataSent.resolutions[mediaType][sendrecvType].jitterBufferDelay) / (statsResults.resolutions[mediaType][sendrecvType].jitterBufferEmittedCount - lastMqaDataSent.resolutions[mediaType][sendrecvType].jitterBufferEmittedCount) * 1000 || 0;
+  // videoReceiver.streams[0].common.rtpJitter = (statsResults.resolutions[mediaType][sendrecvType].jitterBufferDelay - lastMqaDataSent.resolutions[mediaType]?.[sendrecvType].jitterBufferDelay) / (statsResults.resolutions[mediaType][sendrecvType].jitterBufferEmittedCount - lastMqaDataSent.resolutions[mediaType]?.[sendrecvType].jitterBufferEmittedCount) * 1000 || 0;
 
   // Calculate the outgoing bitrate
   const totalBytesReceivedInaMin =
-    statsResults[mediaType][sendrecvType].totalBytesReceived -
-    lastMqaDataSent[mediaType][sendrecvType].totalBytesReceived;
+    statsResults[mediaType][sendrecvType].totalBytesReceived - lastBytesReceived;
 
   videoReceiver.streams[0].common.receivedBitrate = totalBytesReceivedInaMin
     ? (totalBytesReceivedInaMin * 8) / 60
@@ -175,49 +189,50 @@ export const getVideoReceiverMqa = ({
 
   // From tracks //TODO: calculate a proper one
   const totalFrameReceivedInaMin =
-    statsResults.resolutions[mediaType][sendrecvType].framesReceived -
-    lastMqaDataSent.resolutions[mediaType][sendrecvType].framesReceived;
+    statsResults.resolutions[mediaType][sendrecvType].framesReceived - lastFramesReceived;
   const totalFrameDecodedInaMin =
-    statsResults.resolutions[mediaType][sendrecvType].framesDecoded -
-    lastMqaDataSent.resolutions[mediaType][sendrecvType].framesDecoded;
+    statsResults.resolutions[mediaType][sendrecvType].framesDecoded - lastFramesDecoded;
 
-  videoReceiver.streams[0].common.receivedFrameRate = totalFrameReceivedInaMin
-    ? (totalFrameReceivedInaMin * 100) / 60
-    : 0;
-  videoReceiver.streams[0].common.renderedFrameRate = totalFrameDecodedInaMin
-    ? (totalFrameDecodedInaMin * 100) / 60
-    : 0;
+  videoReceiver.streams[0].common.receivedFrameRate = Math.round(
+    totalFrameReceivedInaMin ? totalFrameReceivedInaMin / 60 : 0
+  );
+  videoReceiver.streams[0].common.renderedFrameRate = Math.round(
+    totalFrameDecodedInaMin ? totalFrameDecodedInaMin / 60 : 0
+  );
 
   videoReceiver.streams[0].common.framesDropped =
-    statsResults.resolutions[mediaType][sendrecvType].framesDropped -
-    lastMqaDataSent.resolutions[mediaType][sendrecvType].framesDropped;
+    statsResults.resolutions[mediaType][sendrecvType].framesDropped - lastFramesDropped;
   videoReceiver.streams[0].receivedHeight =
-    statsResults.resolutions[mediaType][sendrecvType].height;
-  videoReceiver.streams[0].receivedWidth = statsResults.resolutions[mediaType][sendrecvType].width;
+    statsResults.resolutions[mediaType][sendrecvType].height || 0;
+  videoReceiver.streams[0].receivedWidth =
+    statsResults.resolutions[mediaType][sendrecvType].width || 0;
   videoReceiver.streams[0].receivedFrameSize =
-    (statsResults.resolutions[mediaType][sendrecvType].height *
-      statsResults.resolutions[mediaType][sendrecvType].height) /
-    256;
+    (videoReceiver.streams[0].receivedHeight * videoReceiver.streams[0].receivedWidth) / 256;
 
   videoReceiver.streams[0].receivedKeyFrames =
-    statsResults[mediaType][sendrecvType].keyFramesDecoded -
-      lastMqaDataSent[mediaType][sendrecvType].keyFramesDecoded || 0;
+    statsResults[mediaType][sendrecvType].keyFramesDecoded - lastKeyFramesDecoded || 0;
   videoReceiver.streams[0].requestedKeyFrames =
-    statsResults[mediaType][sendrecvType].totalPliCount -
-      lastMqaDataSent[mediaType][sendrecvType].totalPliCount || 0;
+    statsResults[mediaType][sendrecvType].totalPliCount - lastPliCount || 0;
 };
 
-export const getVideoSenderMqa = ({
-  videoSender,
-  statsResults,
-  lastMqaDataSent,
-  isShareStream = false,
-}) => {
-  const mediaType = isShareStream ? STATS.SHARE_CORRELATE : STATS.VIDEO_CORRELATE;
+export const getVideoSenderMqa = ({videoSender, statsResults, lastMqaDataSent, mediaType}) => {
   const sendrecvType = STATS.SEND_DIRECTION;
 
+  const lastPacketsSent = lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsSent || 0;
+  const lastPacketsLost =
+    lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsLostOnReceiver || 0;
+  const lastBytesSent = lastMqaDataSent[mediaType]?.[sendrecvType].totalBytesSent || 0;
+  const lastKeyFramesEncoded =
+    lastMqaDataSent.resolutions[mediaType]?.[sendrecvType].totalKeyFramesEncoded || 0;
+  const lastFirCount = lastMqaDataSent[mediaType]?.[sendrecvType].totalFirCount || 0;
+  const lastFramesSent = lastMqaDataSent.resolutions[mediaType]?.[sendrecvType].framesSent || 0;
+  const {csi} = statsResults[mediaType];
+  if (csi && !videoSender.streams[0].common.csi.includes(csi)) {
+    videoSender.streams[0].common.csi.push(csi);
+  }
+
   videoSender.common.common.direction = statsResults[mediaType].direction;
-  videoSender.common.transportType = statsResults.connectionType.local.transport[0];
+  videoSender.common.transportType = statsResults.connectionType.local.transport;
 
   // @ts-ignore
   videoSender.common.maxRemoteJitter =
@@ -227,22 +242,19 @@ export const getVideoSenderMqa = ({
     mean(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
 
   videoSender.common.rtpPackets =
-    statsResults[mediaType][sendrecvType].totalPacketsSent -
-      lastMqaDataSent[mediaType][sendrecvType].totalPacketsSent || 0;
+    statsResults[mediaType][sendrecvType].totalPacketsSent - lastPacketsSent || 0;
   videoSender.common.availableBitrate =
     statsResults[mediaType][sendrecvType].availableOutgoingBitrate || 0;
   // Calculate based on how much packets lost of received compated to how to the client sent
 
   const totalpacketsLostForaMin =
-    statsResults[mediaType][sendrecvType].totalPacketsLostOnReceiver -
-    lastMqaDataSent[mediaType][sendrecvType].totalPacketsLostOnReceiver;
+    statsResults[mediaType][sendrecvType].totalPacketsLostOnReceiver - lastPacketsLost;
 
   videoSender.common.remoteLossRate =
     totalpacketsLostForaMin > 0
       ? (totalpacketsLostForaMin * 100) / (videoSender.common.rtpPackets + totalpacketsLostForaMin)
       : 0; // This is the packets sent with in last min || 0;
 
-  // @ts-ignore
   videoSender.common.maxRoundTripTime =
     // @ts-ignore
     max(statsResults[mediaType][sendrecvType].meanRoundTripTime) * 1000 || 0;
@@ -251,13 +263,10 @@ export const getVideoSenderMqa = ({
   videoSender.common.roundTripTime = videoSender.common.maxRoundTripTime;
 
   videoSender.streams[0].common.rtpPackets =
-    statsResults[mediaType][sendrecvType].totalPacketsSent -
-      lastMqaDataSent[mediaType][sendrecvType].totalPacketsSent || 0;
+    statsResults[mediaType][sendrecvType].totalPacketsSent - lastPacketsSent || 0;
 
   // Calculate the outgoing bitrate
-  const totalBytesSentInaMin =
-    statsResults[mediaType][sendrecvType].totalBytesSent -
-    lastMqaDataSent[mediaType][sendrecvType].totalBytesSent;
+  const totalBytesSentInaMin = statsResults[mediaType][sendrecvType].totalBytesSent - lastBytesSent;
 
   videoSender.streams[0].common.transmittedBitrate = totalBytesSentInaMin
     ? (totalBytesSentInaMin * 8) / 60
@@ -266,25 +275,21 @@ export const getVideoSenderMqa = ({
   videoSender.common.rtpBitrate = videoSender.streams[0].common.transmittedBitrate;
 
   videoSender.streams[0].transmittedKeyFrames =
-    statsResults[mediaType][sendrecvType].totalKeyFramesEncoded -
-      lastMqaDataSent[mediaType][sendrecvType].totalKeyFramesEncoded || 0;
+    statsResults[mediaType][sendrecvType].totalKeyFramesEncoded - lastKeyFramesEncoded || 0;
   videoSender.streams[0].requestedKeyFrames =
-    statsResults[mediaType][sendrecvType].totalFirCount -
-      lastMqaDataSent[mediaType][sendrecvType].totalFirCount || 0;
+    statsResults[mediaType][sendrecvType].totalFirCount - lastFirCount || 0;
 
   // From tracks //TODO: calculate a proper one
   const totalFrameSentInaMin =
-    statsResults.resolutions[mediaType][sendrecvType].framesSent -
-    (lastMqaDataSent.resolutions[mediaType][sendrecvType].framesSent || 0);
+    statsResults.resolutions[mediaType][sendrecvType].framesSent - (lastFramesSent || 0);
 
-  videoSender.streams[0].common.transmittedFrameRate = totalFrameSentInaMin
-    ? (totalFrameSentInaMin * 100) / 60
-    : 0;
+  videoSender.streams[0].common.transmittedFrameRate = Math.round(
+    totalFrameSentInaMin ? totalFrameSentInaMin / 60 : 0
+  );
   videoSender.streams[0].transmittedHeight =
-    statsResults.resolutions[mediaType][sendrecvType].height;
-  videoSender.streams[0].transmittedWidth = statsResults.resolutions[mediaType][sendrecvType].width;
+    statsResults.resolutions[mediaType][sendrecvType].height || 0;
+  videoSender.streams[0].transmittedWidth =
+    statsResults.resolutions[mediaType][sendrecvType].width || 0;
   videoSender.streams[0].transmittedFrameSize =
-    (statsResults.resolutions[mediaType][sendrecvType].height *
-      statsResults.resolutions[mediaType][sendrecvType].width) /
-    254;
+    (videoSender.streams[0].transmittedHeight * videoSender.streams[0].transmittedWidth) / 256;
 };

package/src/webinar/collection.ts

@@ -0,0 +1,31 @@
+/*!
+ * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import {MEETINGS} from '../constants';
+
+class WebinarCollection {
+  webinarInfo: any;
+
+  namespace = MEETINGS;
+
+  mainIndex = 'sessionId';
+
+  constructor() {
+    this.webinarInfo = {};
+  }
+
+  set(id, info) {
+    this.webinarInfo[id] = info;
+  }
+
+  /**
+   * @param {String} id
+   * @returns {Member}
+   */
+  get(id: string) {
+    return this.webinarInfo[id];
+  }
+}
+
+export default WebinarCollection;

package/src/webinar/index.ts

@@ -0,0 +1,62 @@
+/*!
+ * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.
+ */
+import {WebexPlugin} from '@webex/webex-core';
+import {MEETINGS} from '../constants';
+
+import WebinarCollection from './collection';
+
+/**
+ * @class Webinar
+ */
+const Webinar = WebexPlugin.extend({
+  namespace: MEETINGS,
+  collections: {
+    webinar: WebinarCollection,
+  },
+
+  props: {
+    locusUrl: 'string', // appears current webinar's locus url
+    webcastUrl: 'string', // current webinar's webcast url
+    webinarAttendeesSearchingUrl: 'string', // current webinarAttendeesSearching url
+    canManageWebcast: 'boolean', // appears the ability to manage webcast
+  },
+
+  /**
+   * Update the current locus url of the webinar
+   * @param {string} locusUrl // locus url
+   * @returns {void}
+   */
+  locusUrlUpdate(locusUrl) {
+    this.set('locusUrl', locusUrl);
+  },
+
+  /**
+   * Update the current webcast url of the meeting
+   * @param {string} webcastUrl // webcast url
+   * @returns {void}
+   */
+  webcastUrlUpdate(webcastUrl) {
+    this.set('webcastUrl', webcastUrl);
+  },
+
+  /**
+   * Update the current webinarAttendeesSearching url of the meeting
+   * @param {string} webinarAttendeesSearchingUrl // webinarAttendeesSearching url
+   * @returns {void}
+   */
+  webinarAttendeesSearchingUrlUpdate(webinarAttendeesSearchingUrl) {
+    this.set('webinarAttendeesSearchingUrl', webinarAttendeesSearchingUrl);
+  },
+
+  /**
+   * Update whether self has capability to manage start/stop webcast (only host can manage it)
+   * @param {boolean} canManageWebcast
+   * @returns {void}
+   */
+  updateCanManageWebcast(canManageWebcast) {
+    this.set('canManageWebcast', canManageWebcast);
+  },
+});
+
+export default Webinar;