feat(codec-selection): Use the new codec selection API (#2520)

* feat(codec-selection): Use the new codec selection API
https://github.com/w3ctag/design-reviews/issues/836. This allows the client to seamlessly switch between the codecs without having to trigger a renegotiation.
This feature is behind the flag testing.enableCodecSelectionAPI in config.js

* fix(stats): Fix local resolution stats.
The video codec for the local video sources needs to identified differently now, from the codecs field in the RTCRtpSendParameters returned by the browser. We no longer munge the remote SDP to switch to a different codec.

* feat(stats): Feed encodeTime stats for all local SSRCs to the codec selection mechanism.

* fix(codec-selection) Continue to mumge SDP for selecting H.264.

* feat(codec-selection) Make screenshare codec configurable.
If no 'screenshareCodec' is set under videoQuality or p2p settings, AV1 will be selected as default.

* squash: Address review comments

* Update modules/RTC/CodecSelection.js

Co-authored-by: Saúl Ibarra Corretgé <s@saghul.net>

* fix(codec-selection) Add codec to existing stats

---------

Co-authored-by: Saúl Ibarra Corretgé <s@saghul.net>

JitsiConference.js

                 ? config.videoQuality.mobileCodecPreferenceOrder
                 : config.videoQuality?.codecPreferenceOrder,
             disabledCodec: _getCodecMimeType(config.videoQuality?.disabledCodec),
-            preferredCodec: _getCodecMimeType(config.videoQuality?.preferredCodec)
+            preferredCodec: _getCodecMimeType(config.videoQuality?.preferredCodec),
+            screenshareCodec: browser.isMobileDevice()
+                ? _getCodecMimeType(config.videoQuality?.mobileScreenshareCodec)
+                : _getCodecMimeType(config.videoQuality?.screenshareCodec)
         },
         p2p: {
             preferenceOrder: browser.isMobileDevice() && config.p2p?.mobileCodecPreferenceOrder
                 ? config.p2p.mobileCodecPreferenceOrder
                 : config.p2p?.codecPreferenceOrder,
             disabledCodec: _getCodecMimeType(config.p2p?.disabledCodec),
-            preferredCodec: _getCodecMimeType(config.p2p?.preferredCodec)
+            preferredCodec: _getCodecMimeType(config.p2p?.preferredCodec),
+            screenshareCodec: browser.isMobileDevice()
+                ? _getCodecMimeType(config.p2p?.mobileScreenshareCodec)
+                : _getCodecMimeType(config.p2p?.screenshareCodec)
         }
     };
 
                 ...this.options.config,
                 codecSettings: {
                     mediaType: MediaType.VIDEO,
-                    codecList: this.codecSelection.getCodecPreferenceList('jvb')
+                    codecList: this.codecSelection.getCodecPreferenceList('jvb'),
+                    screenshareCodec: this.codecSelection.getScreenshareCodec('jvb')
                 },
                 enableInsertableStreams: this.isE2EEEnabled() || FeatureFlags.isRunInLiteModeEnabled()
             });
             ...this.options.config,
             codecSettings: {
                 mediaType: MediaType.VIDEO,
-                codecList: this.codecSelection.getCodecPreferenceList('p2p')
+                codecList: this.codecSelection.getCodecPreferenceList('p2p'),
+                screenshareCodec: this.codecSelection.getScreenshareCodec('p2p')
             },
             enableInsertableStreams: this.isE2EEEnabled() || FeatureFlags.isRunInLiteModeEnabled()
         });
             ...this.options.config,
             codecSettings: {
                 mediaType: MediaType.VIDEO,
-                codecList: this.codecSelection.getCodecPreferenceList('p2p')
+                codecList: this.codecSelection.getCodecPreferenceList('p2p'),
+                screenshareCodec: this.codecSelection.getScreenshareCodec('p2p')
             },
             enableInsertableStreams: this.isE2EEEnabled() || FeatureFlags.isRunInLiteModeEnabled()
         });

JitsiConferenceEventManager.js

             JitsiConferenceEvents.BEFORE_STATISTICS_DISPOSED);
     });
 
+    conference.statistics.addEncodeTimeStatsListener((tpc, stats) => {
+        conference.eventEmitter.emit(
+            JitsiConferenceEvents.ENCODE_TIME_STATS_RECEIVED, tpc, stats);
+    });
+
     // if we are in startSilent mode we will not be sending/receiving so nothing to detect
     if (!conference.options.config.startSilent) {
         conference.statistics.addByteSentStatsListener((tpc, stats) => {

JitsiConferenceEvents.spec.ts

         E2EE_VERIFICATION_AVAILABLE,
         E2EE_VERIFICATION_READY,
         E2EE_VERIFICATION_COMPLETED,
+        ENCODE_TIME_STATS_RECEIVED,
         ENDPOINT_MESSAGE_RECEIVED,
         ENDPOINT_STATS_RECEIVED,
         JVB121_STATUS,
         expect( BREAKOUT_ROOMS_MOVE_TO_ROOM ).toBe( 'conference.breakout-rooms.move-to-room' );
         expect( BREAKOUT_ROOMS_UPDATED ).toBe( 'conference.breakout-rooms.updated' );
         expect( METADATA_UPDATED ).toBe( 'conference.metadata.updated' );
+        expect( ENCODE_TIME_STATS_RECEIVED ).toBe( 'conference.encode_time_stats_received' );
 
         expect( JitsiConferenceEvents ).toBeDefined();
 
         expect( JitsiConferenceEvents.DOMINANT_SPEAKER_CHANGED ).toBe( 'conference.dominantSpeaker' );
         expect( JitsiConferenceEvents.CONFERENCE_CREATED_TIMESTAMP ).toBe( 'conference.createdTimestamp' );
         expect( JitsiConferenceEvents.DTMF_SUPPORT_CHANGED ).toBe( 'conference.dtmfSupportChanged' );
+        expect( JitsiConferenceEvents.ENCODE_TIME_STATS_RECEIVED ).toBe( 'conference.encode_time_stats_received' );
         expect( JitsiConferenceEvents.ENDPOINT_MESSAGE_RECEIVED ).toBe( 'conference.endpoint_message_received' );
         expect( JitsiConferenceEvents.ENDPOINT_STATS_RECEIVED ).toBe( 'conference.endpoint_stats_received' );
         expect( JitsiConferenceEvents.JVB121_STATUS ).toBe( 'conference.jvb121Status' );

JitsiConferenceEvents.ts

 
     E2EE_VERIFICATION_READY = 'conference.e2ee.verification.ready',
 
+    /**
+     * Indicates that the encode time stats for the local video sources has been received.
+     */
+    ENCODE_TIME_STATS_RECEIVED = 'conference.encode_time_stats_received',
+
     /**
      * Indicates that a message from another participant is received on data
      * channel.
 export const E2EE_VERIFICATION_AVAILABLE = JitsiConferenceEvents.E2EE_VERIFICATION_AVAILABLE;
 export const E2EE_VERIFICATION_COMPLETED = JitsiConferenceEvents.E2EE_VERIFICATION_COMPLETED;
 export const E2EE_VERIFICATION_READY = JitsiConferenceEvents.E2EE_VERIFICATION_READY;
+export const ENCODE_TIME_STATS_RECEIVED = JitsiConferenceEvents.ENCODE_TIME_STATS_RECEIVED;
 export const ENDPOINT_MESSAGE_RECEIVED = JitsiConferenceEvents.ENDPOINT_MESSAGE_RECEIVED;
 export const ENDPOINT_STATS_RECEIVED = JitsiConferenceEvents.ENDPOINT_STATS_RECEIVED;
 export const FORWARDED_SOURCES_CHANGED = JitsiConferenceEvents.FORWARDED_SOURCES_CHANGED;

modules/RTC/CodecSelection.js

      * @param {string} options.p2p settings (codec list, preferred and disabled) for the p2p connection.
      */
     constructor(conference, options) {
+        this.codecPreferenceOrder = {};
         this.conference = conference;
+        this.encodeTimeStats = new Map();
         this.options = options;
-        this.codecPreferenceOrder = {};
+        this.screenshareCodec = {};
         this.visitorCodecs = [];
 
         for (const connectionType of Object.keys(options)) {
             // eslint-disable-next-line prefer-const
-            let { disabledCodec, preferredCodec, preferenceOrder } = options[connectionType];
+            let { disabledCodec, preferredCodec, preferenceOrder, screenshareCodec } = options[connectionType];
             const supportedCodecs = new Set(this._getSupportedVideoCodecs(connectionType));
 
             // Default preference codec order when no codec preferences are set in config.js
 
             logger.info(`Codec preference order for ${connectionType} connection is ${selectedOrder}`);
             this.codecPreferenceOrder[connectionType] = selectedOrder;
+
+            // Set the preferred screenshare codec.
+            if (screenshareCodec && supportedCodecs.has(screenshareCodec)) {
+                this.screenshareCodec[connectionType] = screenshareCodec;
+            }
         }
 
         this.conference.on(
         this.conference.on(
             JitsiConferenceEvents.USER_LEFT,
             () => this._selectPreferredCodec());
+        this.conference.on(
+            JitsiConferenceEvents.ENCODE_TIME_STATS_RECEIVED,
+            (tpc, stats) => this._processEncodeTimeStats(tpc, stats));
     }
 
     /**
         return supportedCodecs;
     }
 
+    /**
+     * Processes the encode time stats received for all the local video sources.
+     *
+     * @param {TraceablePeerConnection} tpc - the peerconnection for which stats were gathered.
+     * @param {Object} stats - the encode time stats for local video sources.
+     * @returns {void}
+     */
+    _processEncodeTimeStats(tpc, stats) {
+        const activeSession = this.conference.getActiveMediaSession();
+
+        // Process stats only for the active media session.
+        if (activeSession.peerconnection !== tpc) {
+            return;
+        }
+
+        const statsPerTrack = new Map();
+
+        for (const ssrc of stats.keys()) {
+            const { codec, encodeTime, qualityLimitationReason, resolution, timestamp } = stats.get(ssrc);
+            const track = tpc.getTrackBySSRC(ssrc);
+            let existingStats = statsPerTrack.get(track.rtcId);
+            const encodeResolution = Math.min(resolution.height, resolution.width);
+            const ssrcStats = {
+                encodeResolution,
+                encodeTime,
+                qualityLimitationReason
+            };
+
+            if (existingStats) {
+                existingStats.codec = codec;
+                existingStats.timestamp = timestamp;
+                existingStats.trackStats.push(ssrcStats);
+            } else {
+                existingStats = {
+                    codec,
+                    timestamp,
+                    trackStats: [ ssrcStats ]
+                };
+
+                statsPerTrack.set(track.rtcId, existingStats);
+            }
+        }
+
+        // Aggregate the stats for multiple simulcast streams with different SSRCs but for the same video stream.
+        for (const trackId of statsPerTrack.keys()) {
+            const { codec, timestamp, trackStats } = statsPerTrack.get(trackId);
+            const totalEncodeTime = trackStats
+                .map(stat => stat.encodeTime)
+                .reduce((totalValue, currentValue) => totalValue + currentValue, 0);
+            const avgEncodeTime = totalEncodeTime / trackStats.length;
+            const { qualityLimitationReason = 'none' }
+                = trackStats.find(stat => stat.qualityLimitationReason !== 'none') ?? {};
+            const encodeResolution = trackStats
+                .map(stat => stat.encodeResolution)
+                .reduce((resolution, currentValue) => Math.max(resolution, currentValue), 0);
+            const localTrack = this.conference.getLocalVideoTracks().find(t => t.rtcId === trackId);
+
+            const exisitingStats = this.encodeTimeStats.get(trackId);
+            const sourceStats = {
+                avgEncodeTime,
+                codec,
+                encodeResolution,
+                qualityLimitationReason,
+                localTrack,
+                timestamp
+            };
+
+            if (exisitingStats) {
+                exisitingStats.push(sourceStats);
+            } else {
+                this.encodeTimeStats.set(trackId, [ sourceStats ]);
+            }
+
+            logger.debug(`Encode stats for ${localTrack}: codec=${codec}, time=${avgEncodeTime},`
+                + `resolution=${encodeResolution}, qualityLimitationReason=${qualityLimitationReason}`);
+        }
+    }
+
     /**
      * Sets the codec on the media session based on the codec preference order configured in config.js and the supported
      * codecs published by the remote participants in their presence.
         if (!session) {
             return;
         }
-        const currentCodecOrder = session.peerconnection.getConfiguredVideoCodecs();
         const isJvbSession = session === this.conference.jvbJingleSession;
-
         let localPreferredCodecOrder = isJvbSession ? this.codecPreferenceOrder.jvb : this.codecPreferenceOrder.p2p;
 
         // E2EE is curently supported only for VP8 codec.
             return;
         }
 
-        // Reconfigure the codecs on the media session.
-        if (!selectedCodecOrder.every((val, index) => val === currentCodecOrder[index])) {
-            session.setVideoCodecs(selectedCodecOrder);
-        }
+        session.setVideoCodecs(selectedCodecOrder);
     }
 
     /**
     getCodecPreferenceList(connectionType) {
         return this.codecPreferenceOrder[connectionType];
     }
+
+    /**
+     * Returns the preferred screenshare codec for the given connection type.
+     *
+     * @param {String} connectionType The media connection type, 'p2p' or 'jvb'.
+     * @returns CodecMimeType
+     */
+    getScreenshareCodec(connectionType) {
+        return this.screenshareCodec[connectionType];
+    }
 }

modules/RTC/CodecSelection.spec.js

             participant1 = new MockParticipant('remote-1');
             conference.addParticipant(participant1, [ 'vp9', 'vp8' ]);
 
-            expect(jingleSession.setVideoCodecs).toHaveBeenCalledTimes(0);
+            expect(jingleSession.setVideoCodecs).toHaveBeenCalledTimes(1);
 
             // Add a third user joining the call with a subset of codecs.
             participant2 = new MockParticipant('remote-2');
 
             // Make p2 leave the call
             conference.removeParticipant(participant2);
-            expect(jingleSession.setVideoCodecs).toHaveBeenCalledTimes(1);
+            expect(jingleSession.setVideoCodecs).toHaveBeenCalledTimes(3);
         });
 
         it('and remote endpoints use the old codec selection logic (RN)', () => {
 
             // Make p1 leave the call
             conference.removeParticipant(participant1);
-            expect(jingleSession.setVideoCodecs).toHaveBeenCalledTimes(2);
+            expect(jingleSession.setVideoCodecs).toHaveBeenCalledTimes(3);
         });
     });
 
             participant1 = new MockParticipant('remote-1');
             conference.addParticipant(participant1, [ 'vp9', 'vp8', 'h264' ]);
 
-            expect(jingleSession.setVideoCodecs).toHaveBeenCalledTimes(0);
+            expect(jingleSession.setVideoCodecs).toHaveBeenCalledTimes(1);
 
             // Add a third user joining the call with a subset of codecs.
             participant2 = new MockParticipant('remote-2');
 
             // Make p2 leave the call
             conference.removeParticipant(participant2);
-            expect(jingleSession.setVideoCodecs).toHaveBeenCalledTimes(1);
+            expect(jingleSession.setVideoCodecs).toHaveBeenCalledTimes(3);
         });
 
         it('and remote endpoint prefers a codec that is locally disabled', () => {
 
             // Make p1 leave the call
             conference.removeParticipant(participant1);
-            expect(jingleSession.setVideoCodecs).toHaveBeenCalledTimes(2);
+            expect(jingleSession.setVideoCodecs).toHaveBeenCalledTimes(3);
         });
     });
 });

modules/RTC/TraceablePeerConnection.js

     browser.supportsCodecPreferences()
         && logger.info('Using RTCRtpTransceiver#setCodecPreferences for codec selection');
 
+    /**
+     * Flag used to indicate if the codecs are configured using the codec selection API without having the need to
+     * trigger a renegotiation for the change to be effective.
+     */
+    this._usesCodecSelectionAPI = this.options.usesCodecSelectionAPI;
+
     /**
      * Indicates whether an audio track has ever been added to the peer connection.
      */
 };
 
 /**
- * Tries to find {@link JitsiTrack} for given SSRC number. It will search both
- * local and remote tracks bound to this instance.
+ * Tries to find {@link JitsiTrack} for given SSRC number. It will search both local and remote tracks bound to this
+ * instance.
  * @param {number} ssrc
  * @return {JitsiTrack|null}
  */
         throw new Error(`SSRC ${ssrc} is not a number`);
     }
     for (const localTrack of this.localTracks.values()) {
-        if (this.getLocalSSRC(localTrack) === ssrc) {
+        const { ssrcs } = this.localSSRCs.get(localTrack.rtcId);
+
+        if (ssrcs.find(localSsrc => Number(localSsrc) === ssrc)) {
             return localTrack;
         }
     }
         }
 
         // Reorder the codecs based on the preferred settings.
-        for (const codec of this.codecSettings.codecList.slice().reverse()) {
-            SDPUtil.preferCodec(mLine, codec, this.isP2P);
+        if (!this.usesCodecSelectionAPI()) {
+            for (const codec of this.codecSettings.codecList.slice().reverse()) {
+                SDPUtil.preferCodec(mLine, codec, this.isP2P);
+            }
         }
     }
 
  * video in the local SDP.
  */
 TraceablePeerConnection.prototype.getConfiguredVideoCodec = function() {
+    const localVideoTrack = this.getLocalVideoTracks()[0];
+
+    if (this.usesCodecSelectionAPI() && localVideoTrack) {
+        const rtpSender = this.findSenderForTrack(localVideoTrack.getTrack());
+        const { codecs } = rtpSender.getParameters();
+
+        return codecs[0].mimeType.split('/')[1].toLowerCase();
+    }
+
     const sdp = this.peerconnection.remoteDescription?.sdp;
     const defaultCodec = CodecMimeType.VP8;
 
     }
 
     this.codecSettings.codecList = codecList;
+
+    if (this.usesCodecSelectionAPI()) {
+        this.configureVideoSenderEncodings();
+    }
 };
 
 /**
     return this.tpcUtils.replaceTrack(localTrack, null).then(() => false);
 };
 
+/**
+ * Returns true if the codec selection API is used for switching between codecs for the video sources.
+ *
+ * @returns {boolean}
+ */
+TraceablePeerConnection.prototype.usesCodecSelectionAPI = function() {
+    // Browser throws an error when H.264 is set on the encodings. Therefore, munge the SDP when H.264 needs to be
+    // selected.
+    // TODO: Remove this check when the above issue is fixed.
+    return this._usesCodecSelectionAPI && this.codecSettings.codecList[0] !== CodecMimeType.H264;
+};
+
 TraceablePeerConnection.prototype.createDataChannel = function(label, opts) {
     this.trace('createDataChannel', label, opts);
 
     });
 };
 
+/**
+ * Returns the codec to be used for screenshare based on the supported codecs and the preferred codec requested
+ * through config.js setting.
+ *
+ * @param {CodecMimeType} defaultCodec - the preferred codec for video tracks.
+ * @returns {CodecMimeType}
+ */
+TraceablePeerConnection.prototype._getPreferredCodecForScreenshare = function(defaultCodec) {
+    // Use the same codec for both camera and screenshare if the client doesn't support the codec selection API.
+    if (!this.usesCodecSelectionAPI()) {
+        return defaultCodec;
+    }
+
+    const { screenshareCodec } = this.codecSettings;
+
+    if (screenshareCodec && this.codecSettings.codecList.find(c => c === screenshareCodec)) {
+        return screenshareCodec;
+    }
+
+    // Default to AV1 for screenshare if its supported and is not overriden through config.js.
+    if (this.codecSettings.codecList.find(c => c === CodecMimeType.AV1)) {
+        return CodecMimeType.AV1;
+    }
+
+    return defaultCodec;
+};
+
 /**
  * Munges the stereo flag as well as the opusMaxAverageBitrate in the SDP, based
  * on values set through config.js, if present.
  * @returns {Promise} promise that will be resolved when the operation is successful and rejected otherwise.
  */
 TraceablePeerConnection.prototype.configureVideoSenderEncodings = function(localVideoTrack = null) {
+    const preferredCodec = this.codecSettings.codecList[0];
+
     if (localVideoTrack) {
         return this.setSenderVideoConstraints(
             this._senderMaxHeights.get(localVideoTrack.getSourceName()),
-            localVideoTrack);
+            localVideoTrack,
+            preferredCodec);
     }
     const promises = [];
 
     for (const track of this.getLocalVideoTracks()) {
         const maxHeight = this._senderMaxHeights.get(track.getSourceName()) ?? VIDEO_QUALITY_LEVELS[0].height;
 
-        promises.push(this.setSenderVideoConstraints(maxHeight, track));
+        promises.push(this.setSenderVideoConstraints(maxHeight, track, preferredCodec));
     }
 
     return Promise.allSettled(promises);
  *
  * @param {number} frameHeight - The max frame height to be imposed on the outgoing video stream.
  * @param {JitsiLocalTrack} - The local track for which the sender constraints have to be applied.
+ * @param {preferredCodec} - The video codec that needs to be configured on the sender associated with the video source.
  * @returns {Promise} promise that will be resolved when the operation is successful and rejected otherwise.
  */
-TraceablePeerConnection.prototype.setSenderVideoConstraints = function(frameHeight, localVideoTrack) {
+TraceablePeerConnection.prototype.setSenderVideoConstraints = function(frameHeight, localVideoTrack, preferredCodec) {
     if (frameHeight < 0 || isNaN(frameHeight)) {
         throw new Error(`Invalid frameHeight: ${frameHeight}`);
     }
         return Promise.resolve();
     }
 
+    const codec = preferredCodec ?? this.codecSettings.codecList[0];
+
     return this._updateVideoSenderParameters(
-        () => this._updateVideoSenderEncodings(frameHeight, localVideoTrack));
+        () => this._updateVideoSenderEncodings(frameHeight, localVideoTrack, codec));
 };
 
 /**
  *
  * @param {number} frameHeight - The max frame height to be imposed on the outgoing video stream.
  * @param {JitsiLocalTrack} - The local track for which the sender constraints have to be applied.
+ * @param {preferredCodec} - The video codec that needs to be configured on the sender associated with the video source.
  * @returns {Promise} promise that will be resolved when the operation is successful and rejected otherwise.
  */
-TraceablePeerConnection.prototype._updateVideoSenderEncodings = function(frameHeight, localVideoTrack) {
+TraceablePeerConnection.prototype._updateVideoSenderEncodings = function(frameHeight, localVideoTrack, preferredCodec) {
     const videoSender = this.findSenderForTrack(localVideoTrack.getTrack());
+    const isScreensharingTrack = localVideoTrack.getVideoType() === VideoType.DESKTOP;
 
     if (!videoSender) {
         return Promise.resolve();
         return Promise.resolve();
     }
 
-    const isSharingLowFpsScreen = localVideoTrack.getVideoType() === VideoType.DESKTOP && this._capScreenshareBitrate;
+    const isSharingLowFpsScreen = isScreensharingTrack && this._capScreenshareBitrate;
 
     // Set the degradation preference.
     const preference = isSharingLowFpsScreen
     parameters.degradationPreference = preference;
 
     // Calculate the encodings active state based on the resolution requested by the bridge.
-    const codec = this.getConfiguredVideoCodec();
+    const codecForCamera = preferredCodec ?? this.getConfiguredVideoCodec(localVideoTrack);
+    const codec = isScreensharingTrack ? this._getPreferredCodecForScreenshare(codecForCamera) : codecForCamera;
     const activeState = this.tpcUtils.calculateEncodingsActiveState(localVideoTrack, codec, frameHeight);
     let bitrates = this.tpcUtils.calculateEncodingsBitrates(localVideoTrack, codec, frameHeight);
     const scalabilityModes = this.tpcUtils.calculateEncodingsScalabilityMode(localVideoTrack, codec, frameHeight);
         if (parameters.encodings.hasOwnProperty(idx)) {
             const {
                 active = undefined,
+                codec: currentCodec = undefined,
                 maxBitrate = undefined,
                 scalabilityMode = undefined,
                 scaleResolutionDownBy = undefined
             } else {
                 parameters.encodings[idx].scalabilityMode = undefined;
             }
+
+            const expectedPattern = `${MediaType.VIDEO}/${codec.toUpperCase()}`;
+
+            // Configure the codec here if its supported.
+            if (this.usesCodecSelectionAPI() && currentCodec?.mimeType !== expectedPattern) {
+                const matchingCodec = parameters.codecs.find(pt => pt.mimeType === expectedPattern);
+
+                parameters.encodings[idx].codec = matchingCodec;
+                needsUpdate = true;
+            }
         }
     }
 

modules/browser/BrowserCapabilities.js

             && !this.isWebKitBased();
     }
 
+    /**
+     * Checks if the browser supports the new codec selection API, i.e., checks if dictionary member
+     * RTCRtpEncodingParameters.codec as defined in
+     * https://w3c.github.io/webrtc-extensions/#dom-rtcrtpencodingparameters-codec is supported by the browser. It
+     * allows the application to change the current codec used by each RTCRtpSender without a renegotiation.
+     *
+     * @returns {boolean}
+     */
+    supportsCodecSelectionAPI() {
+        return this.isChromiumBased() && this.isEngineVersionGreaterThan(125);
+    }
+
     /**
      * Returns true if the browser supports Dependency Descriptor header extension.
      *

modules/statistics/RTPStatsCollector.js

     this.codec = codec || '';
 };
 
+SsrcStats.prototype.setEncodeStats = function(encodeStats) {
+    this.encodeStats = encodeStats || {};
+};
+
 /**
  *
  */
  */
 StatsCollector.prototype.processStatsReport = function() {
     const byteSentStats = {};
+    const encodedTimeStatsPerSsrc = new Map();
 
     this.currentStatsReport.forEach(now => {
         const before = this.previousStatsReport ? this.previousStatsReport.get(now.id) : null;
 
             if (codec) {
                 /**
-                 * The mime type has the following form: video/VP8 or audio/ISAC,
-                 * so we what to keep just the type after the '/', audio and video
-                 * keys will be added on the processing side.
+                 * The mime type has the following form: video/VP8 or audio/ISAC, so we what to keep just the type
+                 * after the '/', audio and video keys will be added on the processing side.
                  */
                 const codecShortType = codec.mimeType.split('/')[1];
 
                 codecShortType && ssrcStats.setCodec(codecShortType);
+
+                // Calculate the encodeTime stat for outbound video streams.
+                const track = this.peerconnection.getTrackBySSRC(ssrc);
+
+                if (now.type === 'outbound-rtp'
+                    && now.active
+                    && track?.isVideoTrack()
+                    && this.peerconnection.usesCodecSelectionAPI()
+                    && before?.totalEncodeTime
+                    && before?.framesEncoded
+                    && now.frameHeight
+                    && now.frameWidth) {
+                    const encodeTimeDelta = now.totalEncodeTime - before.totalEncodeTime;
+                    const framesEncodedDelta = now.framesEncoded - before.framesEncoded;
+                    const encodeTimePerFrameInMs = 1000 * encodeTimeDelta / framesEncodedDelta;
+                    const encodeTimeStats = {
+                        codec: codecShortType,
+                        encodeTime: encodeTimePerFrameInMs,
+                        qualityLimitationReason: now.qualityLimitationReason,
+                        resolution,
+                        timestamp: now.timestamp
+                    };
+
+                    encodedTimeStatsPerSsrc.set(ssrc, encodeTimeStats);
+                    ssrcStats.setEncodeStats(encodedTimeStatsPerSsrc);
+                }
             }
 
         // Continue to use the 'track' based stats for Firefox and Safari and older versions of Chromium.
         this.eventEmitter.emit(StatisticsEvents.BYTE_SENT_STATS, this.peerconnection, byteSentStats);
     }
 
+    if (encodedTimeStatsPerSsrc.size) {
+        this.eventEmitter.emit(StatisticsEvents.ENCODE_TIME_STATS, this.peerconnection, encodedTimeStatsPerSsrc);
+    }
+
     this._processAndEmitReport();
 };

modules/statistics/statistics.js

         listener);
 };
 
+Statistics.prototype.addEncodeTimeStatsListener = function(listener) {
+    this.eventEmitter.on(StatisticsEvents.ENCODE_TIME_STATS, listener);
+};
+
+Statistics.prototype.removeEncodeTimeStatsListener = function(listener) {
+    this.eventEmitter.removeListener(StatisticsEvents.ENCODE_TIME_STATS, listener);
+};
+
 Statistics.prototype.addByteSentStatsListener = function(listener) {
     this.eventEmitter.on(StatisticsEvents.BYTE_SENT_STATS, listener);
 };

modules/xmpp/JingleSessionPC.js

 import { $build, $iq, Strophe } from 'strophe.js';
 
 import { JitsiTrackEvents } from '../../JitsiTrackEvents';
+import { CodecMimeType } from '../../service/RTC/CodecMimeType';
 import { MediaDirection } from '../../service/RTC/MediaDirection';
 import { MediaType } from '../../service/RTC/MediaType';
 import {
         pcOptions.capScreenshareBitrate = false;
         pcOptions.codecSettings = options.codecSettings;
         pcOptions.enableInsertableStreams = options.enableInsertableStreams;
+        pcOptions.usesCodecSelectionAPI = this.usesCodecSelectionAPI
+            = browser.supportsCodecSelectionAPI() && options.testing?.enableCodecSelectionAPI;
 
         if (options.videoQuality) {
             const settings = Object.entries(options.videoQuality)
      * Updates the codecs on the peerconnection and initiates a renegotiation for the
      * new codec config to take effect.
      *
-     * @param {CodecMimeType} preferred the preferred codec.
-     * @param {CodecMimeType} disabled the codec that needs to be disabled.
+     * @param {Array<CodecMimeType>} codecList the preferred codecs.
      */
     setVideoCodecs(codecList) {
+
         if (this._assertNotEnded()) {
             logger.info(`${this} setVideoCodecs: ${codecList}`);
             this.peerconnection.setVideoCodecs(codecList);
 
+            // Browser throws an error when H.264 is set on the encodings. Therefore, munge the SDP when H.264 needs to
+            // be selected.
+            // TODO: Remove this check when the above issue is fixed.
+            if (this.usesCodecSelectionAPI && codecList[0] !== CodecMimeType.H264) {
+                return;
+            }
+
+            // Skip renegotiation when the selected codec order matches with that of the remote SDP.
+            const currentCodecOrder = this.peerconnection.getConfiguredVideoCodecs();
+
+            if (codecList.every((val, index) => val === currentCodecOrder[index])) {
+                return;
+            }
+
             // Initiate a renegotiate for the codec setting to take effect.
             const workFunction = finishedCallback => {
                 this._renegotiate()

service/statistics/Events.spec.ts

         BEFORE_DISPOSED,
         BYTE_SENT_STATS,
         CONNECTION_STATS,
+        ENCODE_TIME_STATS,
         LONG_TASKS_STATS,
         Events,
         ...others
         expect( BEFORE_DISPOSED ).toBe( 'statistics.before_disposed' );
         expect( BYTE_SENT_STATS ).toBe( 'statistics.byte_sent_stats' );
         expect( CONNECTION_STATS ).toBe( 'statistics.connectionstats' );
+        expect( ENCODE_TIME_STATS ).toBe( 'statistics.encode_time_stats' );
         expect( LONG_TASKS_STATS ).toBe( 'statistics.long_tasks_stats' );
 
         expect( Events ).toBeDefined();
         expect( Events.BEFORE_DISPOSED ).toBe( 'statistics.before_disposed' );
         expect( Events.BYTE_SENT_STATS ).toBe( 'statistics.byte_sent_stats' );
         expect( Events.CONNECTION_STATS ).toBe( 'statistics.connectionstats' );
+        expect( Events.ENCODE_TIME_STATS ).toBe( 'statistics.encode_time_stats' );
         expect( Events.LONG_TASKS_STATS ).toBe( 'statistics.long_tasks_stats' );
     } );
 

service/statistics/Events.ts

      */
     CONNECTION_STATS = 'statistics.connectionstats',
 
+    /**
+     * An event carrying the encode time stats for all the local video sources.
+     */
+    ENCODE_TIME_STATS = 'statistics.encode_time_stats',
+
     /**
      * An event carrying performance stats.
      */
 export const BEFORE_DISPOSED = Events.BEFORE_DISPOSED;
 export const BYTE_SENT_STATS = Events.BYTE_SENT_STATS;
 export const CONNECTION_STATS = Events.CONNECTION_STATS;
+export const ENCODE_TIME_STATS = Events.ENCODE_TIME_STATS;
 export const LONG_TASKS_STATS = Events.LONG_TASKS_STATS;