chore(*) fix sue of isNaN

- It can throw exceptions
- It doesn't return false on things which are not Number, just on things
  that are not NaN

Fixes: https://github.com/jitsi/lib-jitsi-meet/issues/2743

JitsiConference.js

 import SpeakerStatsCollector from './modules/statistics/SpeakerStatsCollector';
 import Statistics from './modules/statistics/statistics';
 import EventEmitter from './modules/util/EventEmitter';
-import { safeSubtract } from './modules/util/MathUtil';
+import { isValidNumber, safeSubtract } from './modules/util/MathUtil';
 import RandomUtil from './modules/util/RandomUtil';
 import { getJitterDelay } from './modules/util/Retry';
 import ComponentsVersions from './modules/version/ComponentsVersions';
      */
     this.deferredStartP2PTask = null;
 
-    const delay
-        = parseInt(options.config.p2p && options.config.p2p.backToP2PDelay, 10);
+    const delay = Number.parseInt(options.config.p2p?.backToP2PDelay, 10);
 
     /**
      * A delay given in seconds, before the conference switches back to P2P
      * after the 3rd participant has left.
      * @type {number}
      */
-    this.backToP2PDelay = isNaN(delay) ? 5 : delay;
+    this.backToP2PDelay = isValidNumber(delay) ? delay : 5;
     logger.info(`backToP2PDelay: ${this.backToP2PDelay}`);
 
     /**
         done = true;
     }
 
-    if (!isNaN(this.p2pEstablishmentDuration)
-        && !isNaN(this.jvbEstablishmentDuration)) {
+    if (isValidNumber(this.p2pEstablishmentDuration)
+            && isValidNumber(this.jvbEstablishmentDuration)) {
         const establishmentDurationDiff
             = this.p2pEstablishmentDuration - this.jvbEstablishmentDuration;
 
  * @returns {boolean} true if the operation is successful, false otherwise.
  */
 JitsiConference.prototype.setDesktopSharingFrameRate = function(maxFps) {
-    if (typeof maxFps !== 'number' || isNaN(maxFps)) {
+    if (!isValidNumber(maxFps)) {
         logger.error(`Invalid value ${maxFps} specified for desktop capture frame rate`);
 
         return false;
     }
 
-    this._desktopSharingFrameRate = maxFps;
+    const fps = Number(maxFps);
+
+    this._desktopSharingFrameRate = fps;
 
     // Set capture fps for screenshare.
-    this.jvbJingleSession && this.jvbJingleSession.peerconnection.setDesktopSharingFrameRate(maxFps);
+    this.jvbJingleSession && this.jvbJingleSession.peerconnection.setDesktopSharingFrameRate(fps);
 
     // Set the capture rate for desktop sharing.
-    this.rtc.setDesktopSharingFrameRate(maxFps);
+    this.rtc.setDesktopSharingFrameRate(fps);
 
     return true;
 };

modules/RTC/JitsiLocalTrack.js

 } from '../../service/statistics/AnalyticsEvents';
 import browser from '../browser';
 import Statistics from '../statistics/statistics';
+import { isValidNumber } from '../util/MathUtil';
 
 import JitsiTrack from './JitsiTrack';
 import RTCUtils from './RTCUtils';
                 }
 
                 // If the constraints are still empty, fallback to the constraints used for initial gUM.
-                if (isNaN(this._constraints.height.ideal) && isNaN(this._constraints.width.ideal)) {
+                if (!isValidNumber(this._constraints.height.ideal) && !isValidNumber(this._constraints.width.ideal)) {
                     this._constraints.height = { ideal: constraints.height.ideal };
                     this._constraints.width = { ideal: constraints.width.ideal };
                 }
             // picked for the given constraints, fallback to the constraints if MediaStreamTrack.getSettings() doesn't
             // return the height.
             this.resolution = this.getHeight();
-            if (isNaN(this.resolution) && this._constraints.height?.ideal) {
+            if (!isValidNumber(this.resolution) && this._constraints.height?.ideal) {
                 this.resolution = this._constraints.height.ideal;
             }
             this.maxEnabledResolution = this.resolution;
      * @param {number} ssrc The SSRC.
      */
     setSsrc(ssrc) {
-        if (!isNaN(ssrc)) {
+        if (isValidNumber(ssrc)) {
             this._ssrc = ssrc;
         }
     }

modules/RTC/JitsiRemoteTrack.js

 import { createTtfmEvent } from '../../service/statistics/AnalyticsEvents';
 import TrackStreamingStatusImpl, { TrackStreamingStatus } from '../connectivity/TrackStreamingStatus';
 import Statistics from '../statistics/statistics';
+import { isValidNumber } from '../util/MathUtil';
 
 import JitsiTrack from './JitsiTrack';
 
         const gumStart = window.connectionTimes['obtainPermissions.start'];
         const gumEnd = window.connectionTimes['obtainPermissions.end'];
         const gumDuration
-            = !isNaN(gumEnd) && !isNaN(gumStart) ? gumEnd - gumStart : 0;
+            = isValidNumber(gumEnd) && isValidNumber(gumStart) ? gumEnd - gumStart : 0;
 
         // Subtract the muc.joined-to-session-initiate duration because jicofo
         // waits until there are 2 participants to start Jingle sessions.

modules/RTC/RTCUtils.js

 import browser from '../browser';
 import Statistics from '../statistics/statistics';
 import Listenable from '../util/Listenable';
+import { isValidNumber } from '../util/MathUtil';
 
 import screenObtainer from './ScreenObtainer';
 
         return new Promise((resolve, reject) => {
             let gumTimeout, timeoutExpired = false;
 
-            if (typeof timeout === 'number' && !isNaN(timeout) && timeout > 0) {
+            if (isValidNumber(timeout) && timeout > 0) {
                 gumTimeout = setTimeout(() => {
                     timeoutExpired = true;
                     gumTimeout = undefined;
                     if (jitsiError.name === JitsiTrackErrors.PERMISSION_DENIED) {
                         this._updateGrantedPermissions(umDevices, undefined);
                     }
-
-                    // else {
-                    // Probably the error is not caused by the lack of permissions and we don't need to update them.
-                    // }
                 });
         });
     }

modules/RTC/TraceablePeerConnection.js

 import SdpSimulcast from '../sdp/SdpSimulcast';
 import { SdpTransformWrap } from '../sdp/SdpTransformUtil';
 import Statistics from '../statistics/statistics';
+import { isValidNumber } from '../util/MathUtil';
 
 import JitsiRemoteTrack from './JitsiRemoteTrack';
 import RTCUtils from './RTCUtils';
     const trackSsrc = Number(ssrcStr);
     const ownerEndpointId = this.signalingLayer.getSSRCOwner(trackSsrc);
 
-    if (isNaN(trackSsrc) || trackSsrc < 0) {
+    if (!isValidNumber(trackSsrc) || trackSsrc < 0) {
         logger.error(`Invalid SSRC for remote stream[ssrc=${trackSsrc},id=${streamId},type=${mediaType}]`
                 + 'track creation failed!');
 
  * @returns {Promise} promise that will be resolved when the operation is successful and rejected otherwise.
  */
 TraceablePeerConnection.prototype.setSenderVideoConstraints = function(frameHeight, localVideoTrack, preferredCodec) {
-    if (frameHeight < 0 || isNaN(frameHeight)) {
+    if (frameHeight < 0 || !isValidNumber(frameHeight)) {
         throw new Error(`Invalid frameHeight: ${frameHeight}`);
     }
     if (!localVideoTrack) {

modules/qualitycontrol/QualityController.ts

 } from '../../service/RTC/StandardVideoQualitySettings';
 import JitsiLocalTrack from '../RTC/JitsiLocalTrack';
 import TraceablePeerConnection from '../RTC/TraceablePeerConnection';
+import { isValidNumber } from '../util/MathUtil';
 import JingleSessionPC from '../xmpp/JingleSessionPC';
 
 import { CodecSelection } from './CodecSelection';
         const { encodeResolution, localTrack, qualityLimitationReason, tpc } = sourceStats;
 
         // Older browser versions might not report the resolution in the stats.
-        if (Number.isNaN(encodeResolution)) {
+        if (!isValidNumber(encodeResolution)) {
             return;
         }
         const trackId = localTrack.rtcId;

modules/statistics/AvgRTPStatsReporter.js

     createTransportStatsEvent
 } from '../../service/statistics/AnalyticsEvents';
 import browser from '../browser';
+import { isValidNumber } from '../util/MathUtil';
 
 import Statistics from './statistics';
 
 
         if (typeof nextValue !== 'number') {
             logger.error(`${this.name} - invalid value for idx: ${this.count}`, nextValue);
-        } else if (!isNaN(nextValue)) {
+        } else if (isValidNumber(nextValue)) {
             this.sum += nextValue;
             this.samples.push(nextValue);
             this.count += 1;
                     const jvbEnd2EndRTT = this
                         ._avgRtpStatsReporter.jvbStatsMonitor._avgEnd2EndRTT;
 
-                    if (!isNaN(jvbEnd2EndRTT)) {
+                    if (isValidNumber(jvbEnd2EndRTT)) {
                         // eslint-disable-next-line dot-notation
                         batchReport['rtt_diff']
                             = this._avgRTT.calculate() - jvbEnd2EndRTT;
 
                     this._avgEnd2EndRTT = avgLocalRTT + avgRemoteRTT;
 
-                    if (!isNaN(avgLocalRTT) && !isNaN(avgRemoteRTT)) {
+                    if (isValidNumber(avgLocalRTT) && isValidNumber(avgRemoteRTT)) {
                         // eslint-disable-next-line dot-notation
                         batchReport['end2end_rtt_avg'] = this._avgEnd2EndRTT;
                     }
         for (const remoteAvg of this._avgRemoteRTTMap.values()) {
             const avg = remoteAvg.calculate();
 
-            if (!isNaN(avg)) {
+            if (isValidNumber(avg)) {
                 sum += avg;
                 count += 1;
                 remoteAvg.reset();
             this._avgPacketLossTotal.appendReport(batchReport);
 
             this._avgRemoteFPS.appendReport(batchReport);
-            if (!isNaN(this._avgRemoteScreenFPS.calculate())) {
+            if (isValidNumber(this._avgRemoteScreenFPS.calculate())) {
                 this._avgRemoteScreenFPS.appendReport(batchReport);
             }
             this._avgLocalFPS.appendReport(batchReport);
-            if (!isNaN(this._avgLocalScreenFPS.calculate())) {
+            if (isValidNumber(this._avgLocalScreenFPS.calculate())) {
                 this._avgLocalScreenFPS.appendReport(batchReport);
             }
 
             this._avgRemoteCameraPixels.appendReport(batchReport);
-            if (!isNaN(this._avgRemoteScreenPixels.calculate())) {
+            if (isValidNumber(this._avgRemoteScreenPixels.calculate())) {
                 this._avgRemoteScreenPixels.appendReport(batchReport);
             }
             this._avgLocalCameraPixels.appendReport(batchReport);
-            if (!isNaN(this._avgLocalScreenPixels.calculate())) {
+            if (isValidNumber(this._avgLocalScreenPixels.calculate())) {
                 this._avgLocalScreenPixels.appendReport(batchReport);
             }
 
                     const peerAvgPixels = this._calculatePeerAvgVideoPixels(
                         videosResolution, participant, videoType);
 
-                    if (!isNaN(peerAvgPixels)) {
+                    if (isValidNumber(peerAvgPixels)) {
                         peerPixelsSum += peerAvgPixels;
                         peerCount += 1;
                     }
                 = Number(videos[ssrc].height) * Number(videos[ssrc].width);
 
             // FPS is reported as 0 for users with no video
-            if (!isNaN(peerSsrcPixels) && peerSsrcPixels > 0) {
+            if (isValidNumber(peerSsrcPixels) && peerSsrcPixels > 0) {
                 peerPixelsSum += peerSsrcPixels;
                 peerSsrcCount += 1;
             }
                         = this._calculatePeerAvgVideoFps(
                             videosFps, participant, videoType);
 
-                    if (!isNaN(peerAvgFPS)) {
+                    if (isValidNumber(peerAvgFPS)) {
                         peerFpsSum += peerAvgFPS;
                         peerCount += 1;
                     }
             const peerSsrcFps = Number(videos[ssrc]);
 
             // FPS is reported as 0 for users with no video
-            if (!isNaN(peerSsrcFps) && peerSsrcFps > 0) {
+            if (isValidNumber(peerSsrcFps) && peerSsrcFps > 0) {
                 peerFpsSum += peerSsrcFps;
                 peerSsrcCount += 1;
             }

modules/statistics/RTPStatsCollector.js

 import * as StatisticsEvents from '../../service/statistics/Events';
 import browser from '../browser';
 import FeatureFlags from '../flags/FeatureFlags';
+import { isValidNumber } from '../util/MathUtil';
 
 const logger = getLogger('modules/statistics/RTPStatsCollector');
 
             if (!FeatureFlags.isSsrcRewritingSupported()) {
                 logger.error(`No participant ID returned by ${track}`);
             }
-            continue; // eslint-disable-line no-continue
+            continue;
         }
 
         const userCodecs = codecs[participantId] ?? { };
         const { resolution } = ssrcStats;
 
         if (!track.isVideoTrack()
-            || isNaN(resolution?.height)
-            || isNaN(resolution?.width)
+            || !isValidNumber(resolution?.height)
+            || !isValidNumber(resolution?.width)
             || resolution.height === -1
             || resolution.width === -1) {
-            continue; // eslint-disable-line no-continue
+            continue;
         }
         const userResolutions = resolutions[participantId] || {};
 
         value = Number(value);
     }
 
-    if (isNaN(value)) {
+    if (!isValidNumber(value)) {
         return 0;
     }
 

modules/util/MathUtil.ts

  * @returns {number} - x - y or 0 if x or y is not a number.
  */
 export function safeSubtract(x: any, y: any): number {
-    return !isNaN(x) && !isNaN(y) ? x - y : 0;
+    return isValidNumber(x) && isValidNumber(y) ? x - y : 0;
+}
+
+/**
+ * Checks if the given value is a valid number.
+ *
+ * @param n - The value to check.
+ * @returns - `true` if the value is a valid number, `false` otherwise.
+ */
+export function isValidNumber(n: any): boolean {
+    const v = Number.parseInt(n, 10);
+
+    return Number.isFinite(v); // Filter out NaN and Infinity.
 }

service/RTC/SignalingLayer.ts

 import Listenable from '../../modules/util/Listenable';
+import { isValidNumber } from '../../modules/util/MathUtil';
 
 import { MediaType } from './MediaType';
 import { VideoType } from './VideoType';
     const nameParts = sourceName.split('-');
     const trackIdx = Number(nameParts[nameParts.length - 1].substring(1));
 
-    if (Number.isNaN(trackIdx)) {
+    if (!isValidNumber(trackIdx)) {
         throw new Error(`Failed to parse track idx for source name: ${sourceName}`);
     }