ref(sdp): Move all instances of a preferred codec up the list in the SDP

Make sdp munging logic for changing codec preferences more generic
Do not negotiate High profile H264 codecs on when RN clients are in the call

modules/RTC/TraceablePeerConnection.js

      */
     this.senderVideoMaxHeight = null;
 
+    // Set the codec preference that will be applied on the SDP
+    // based on the config.js settings.
+    if (this.options.preferH264 || this.options.preferVP9) {
+        this.codecPreference = {
+            enable: true,
+            mediaType: MediaType.VIDEO,
+            mimeType: this.options.preferH264
+                ? 'h264'
+                : 'vp9'
+        };
+    }
+
+    // If both enable and disable are set for the same codec, disable
+    // setting will prevail.
+    if (this.options.disableH264 || this.options.disableVP9) {
+        this.codecPreference = {
+            enable: false,
+            mediaType: MediaType.VIDEO,
+            mimeType: this.options.disableH264
+                ? 'h264'
+                : 'vp9'
+        };
+    }
+
     // override as desired
     this.trace = (what, info) => {
         logger.debug(what, info);
     return this.localSSRCs.get(rtcId);
 };
 
+/**
+ * Munges the order of the codecs in the SDP passed based on the preference
+ * set through config.js settings. All instances of the specified codec are
+ * moved up to the top of the list when it is preferred. The specified codec
+ * is deleted from the list if the configuration specifies that the codec be
+ * disabled.
+ * @param {RTCSessionDescription} description that needs to be munged.
+ * @returns {RTCSessionDescription} the munged description.
+ */
+TraceablePeerConnection.prototype._mungeCodecOrder = function(description) {
+    if (!this.codecPreference || browser.supportsCodecPreferences()) {
+        return description;
+    }
+
+    const parsedSdp = transform.parse(description.sdp);
+    const mLine = parsedSdp.media.find(m => m.type === this.codecPreference.mediaType);
+
+    if (this.codecPreference.enable && this.codecPreference.mimeType) {
+        SDPUtil.preferCodec(mLine, this.codecPreference.mimeType);
+
+        // Strip the high profile H264 codecs on mobile clients for p2p connection.
+        // High profile codecs give better quality at the expense of higher load which
+        // we do not want on mobile clients.
+        // Jicofo offers only the baseline code for the jvb connection.
+        // TODO - add check for mobile browsers once js-utils provides that check.
+        if (this.codecPreference.mimeType === 'h264' && browser.isReactNative() && this.isP2P) {
+            SDPUtil.stripCodec(mLine, this.codecPreference.mimeType, true /* high profile */);
+        }
+    } else if (this.codecPreference.mimeType) {
+        SDPUtil.stripCodec(mLine, this.codecPreference.mimeType);
+    }
+
+    return new RTCSessionDescription({
+        type: description.type,
+        sdp: transform.write(parsedSdp)
+    });
+};
+
 /**
  * Checks if given track belongs to this peerconnection instance.
  *
 
     this.trace('setLocalDescription::preTransform', dumpSDP(localSdp));
 
-    if (this.options.disableH264 || this.options.preferH264) {
-        const parsedSdp = transform.parse(localSdp.sdp);
-        const videoMLine = parsedSdp.media.find(m => m.type === 'video');
-
-        if (this.options.disableH264) {
-            SDPUtil.stripVideoCodec(videoMLine, 'h264');
-        } else {
-            SDPUtil.preferVideoCodec(videoMLine, 'h264');
-        }
-
-        localSdp = new RTCSessionDescription({
-            type: localSdp.type,
-            sdp: transform.write(parsedSdp)
-        });
-
-        this.trace('setLocalDescription::postTransform (H264)',
-            dumpSDP(localSdp));
-    }
+    // Munge the order of the codecs based on the preferences set through config.js
+    // eslint-disable-next-line no-param-reassign
+    description = this._mungeCodecOrder(localSdp);
 
     if (browser.usesPlanB()) {
         localSdp = this._adjustLocalMediaDirection(localSdp);
 TraceablePeerConnection.prototype.setRemoteDescription = function(description) {
     this.trace('setRemoteDescription::preTransform', dumpSDP(description));
 
+    // Munge the order of the codecs based on the preferences set through config.js
+    // eslint-disable-next-line no-param-reassign
+    description = this._mungeCodecOrder(description);
+
     if (browser.usesPlanB()) {
         // TODO the focus should squeze or explode the remote simulcast
         if (this.isSimulcastOn()) {
                 dumpSDP(description));
         }
 
-        if (this.options.preferH264) {
-            const parsedSdp = transform.parse(description.sdp);
-            const videoMLine = parsedSdp.media.find(m => m.type === 'video');
-
-            SDPUtil.preferVideoCodec(videoMLine, 'h264');
-
-            // eslint-disable-next-line no-param-reassign
-            description = new RTCSessionDescription({
-                type: description.type,
-                sdp: transform.write(parsedSdp)
-            });
-        }
-
         // eslint-disable-next-line no-param-reassign
         description = normalizePlanB(description);
     } else {

modules/browser/BrowserCapabilities.js

         return !this.isFirefox() && !this.isSafari();
     }
 
+    /**
+     * Checks if the current browser supports setting codec preferences on the transceiver.
+     * @returns {boolean}
+     */
+    supportsCodecPreferences() {
+        return this.usesUnifiedPlan()
+            && typeof window.RTCRtpTransceiver !== 'undefined'
+            && Object.keys(window.RTCRtpTransceiver.prototype).indexOf('setCodecPreferences') > -1
+            && Object.keys(RTCRtpSender.prototype).indexOf('getCapabilities') > -1
+
+            // this is not working on Safari because of the following bug
+            // https://bugs.webkit.org/show_bug.cgi?id=215567
+            && !this.isSafari();
+    }
+
     /**
      * Checks if the current browser support the device change event.
      * @return {boolean}

modules/xmpp/JingleSessionPC.js

             pcOptions.disableSimulcast = true;
             pcOptions.disableH264 = options.p2p && options.p2p.disableH264;
             pcOptions.preferH264 = options.p2p && options.p2p.preferH264;
+            pcOptions.preferVP9 = options.p2p && options.p2p.preferVP9;
 
             const abtestSuspendVideo = this._abtestSuspendVideoEnabled(options);
 
                 = options.disableSimulcast
                     || (options.preferH264 && !options.disableH264);
             pcOptions.preferH264 = options.preferH264;
+            pcOptions.preferVP9 = options.preferVP9;
 
             // disable simulcast for screenshare and set the max bitrate to
             // 500Kbps if the testing flag is present in config.js.

modules/xmpp/SDPUtil.js

     },
 
     /**
-     * Sets the given codecName as the preferred codec by
-     *  moving it to the beginning of the payload types
-     *  list (modifies the given mline in place).  If there
-     *  are multiple options within the same codec (multiple h264
-     *  profiles, for instance), this will prefer the first one
-     *  that is found.
-     * @param {object} videoMLine the video mline object from
-     *  an sdp as parsed by transform.parse
+     * Sets the given codecName as the preferred codec by moving it to the beginning
+     * of the payload types list (modifies the given mline in place). All instances
+     * of the codec are moved up.
+     * @param {object} mLine the mline object from an sdp as parsed by transform.parse
      * @param {string} codecName the name of the preferred codec
      */
-    preferVideoCodec(videoMLine, codecName) {
-        let payloadType = null;
-
-        if (!videoMLine || !codecName) {
+    preferCodec(mline, codecName) {
+        if (!mline || !codecName) {
             return;
         }
 
-        for (let i = 0; i < videoMLine.rtp.length; ++i) {
-            const rtp = videoMLine.rtp[i];
+        const matchingPayloadTypes = mline.rtp
+            .filter(rtp => rtp.codec && rtp.codec.toLowerCase() === codecName.toLowerCase())
+            .map(rtp => rtp.payload);
 
-            if (rtp.codec
-                && rtp.codec.toLowerCase() === codecName.toLowerCase()) {
-                payloadType = rtp.payload;
-                break;
-            }
-        }
-        if (payloadType) {
-            // Call toString() on payloads to get around an issue within
-            // SDPTransform that sets payloads as a number, instead of a string,
-            // when there is only one payload.
+        if (matchingPayloadTypes) {
+            // Call toString() on payloads to get around an issue within SDPTransform that sets
+            // payloads as a number, instead of a string, when there is only one payload.
             const payloadTypes
-                = videoMLine.payloads
-                    .toString()
-                    .split(' ')
-                    .map(p => parseInt(p, 10));
-            const payloadIndex = payloadTypes.indexOf(payloadType);
+                = mline.payloads
+                .toString()
+                .split(' ')
+                .map(p => parseInt(p, 10));
+
+            for (const pt of matchingPayloadTypes.reverse()) {
+                const payloadIndex = payloadTypes.indexOf(pt);
 
-            payloadTypes.splice(payloadIndex, 1);
-            payloadTypes.unshift(payloadType);
-            videoMLine.payloads = payloadTypes.join(' ');
+                payloadTypes.splice(payloadIndex, 1);
+                payloadTypes.unshift(pt);
+            }
+            mline.payloads = payloadTypes.join(' ');
         }
     },
 
      * types are also stripped. If the resulting mline would have no codecs,
      * it's disabled.
      *
-     * @param {object} videoMLine the video mline object from an sdp as parsed
-     * by transform.parse.
+     * @param {object} mLine the mline object from an sdp as parsed by transform.parse.
      * @param {string} codecName the name of the codec which will be stripped.
      */
-    stripVideoCodec(videoMLine, codecName) {
-        if (!videoMLine || !codecName) {
+    stripCodec(mLine, codecName, highProfile = false) {
+        if (!mLine || !codecName) {
             return;
         }
 
-        const removePts = [];
+        const h264Pts = [];
+        let removePts = [];
+        const stripH264HighCodec = codecName.toLowerCase() === 'h264' && highProfile;
 
-        for (const rtp of videoMLine.rtp) {
+        for (const rtp of mLine.rtp) {
             if (rtp.codec
                 && rtp.codec.toLowerCase() === codecName.toLowerCase()) {
-                removePts.push(rtp.payload);
+                if (stripH264HighCodec) {
+                    h264Pts.push(rtp.payload);
+                } else {
+                    removePts.push(rtp.payload);
+                }
             }
         }
 
+        // high profile H264 codecs have 64 as the first two bytes of the profile-level-id.
+        if (stripH264HighCodec) {
+            removePts = mLine.fmtp
+                .filter(item => h264Pts.indexOf(item.payload) > -1 && item.config.includes('profile-level-id=64'))
+                .map(item => item.payload);
+        }
+
         if (removePts.length > 0) {
             // We also need to remove the payload types that are related to RTX
             // for the codecs we want to disable.
             const rtxApts = removePts.map(item => `apt=${item}`);
-            const rtxPts = videoMLine.fmtp.filter(
+            const rtxPts = mLine.fmtp.filter(
                 item => rtxApts.indexOf(item.config) !== -1);
 
             removePts.push(...rtxPts.map(item => item.payload));
             // Call toString() on payloads to get around an issue within
             // SDPTransform that sets payloads as a number, instead of a string,
             // when there is only one payload.
-            const allPts = videoMLine.payloads
+            const allPts = mLine.payloads
                 .toString()
                 .split(' ')
                 .map(Number);
             const keepPts = allPts.filter(pt => removePts.indexOf(pt) === -1);
 
             if (keepPts.length === 0) {
-                // There are no other video codecs, disable the stream.
-                videoMLine.port = 0;
-                videoMLine.direction = 'inactive';
-                videoMLine.payloads = '*';
+                // There are no other codecs, disable the stream.
+                mLine.port = 0;
+                mLine.direction = 'inactive';
+                mLine.payloads = '*';
             } else {
-                videoMLine.payloads = keepPts.join(' ');
+                mLine.payloads = keepPts.join(' ');
             }
 
-            videoMLine.rtp = videoMLine.rtp.filter(
+            mLine.rtp = mLine.rtp.filter(
                 item => keepPts.indexOf(item.payload) !== -1);
-            videoMLine.fmtp = videoMLine.fmtp.filter(
+            mLine.fmtp = mLine.fmtp.filter(
                 item => keepPts.indexOf(item.payload) !== -1);
-            if (videoMLine.rtcpFb) {
-                videoMLine.rtcpFb = videoMLine.rtcpFb.filter(
+            if (mLine.rtcpFb) {
+                mLine.rtcpFb = mLine.rtcpFb.filter(
                     item => keepPts.indexOf(item.payload) !== -1);
             }
         }

modules/xmpp/SDPUtil.spec.js

         expect(parsed).toEqual('3jlcc1b3j1rqt6');
     });
 
-    describe('preferVideoCodec', () => {
-        it('should move a preferred codec to the front', () => {
+    describe('preferCodec for video codec', () => {
+        it('should move a preferred video codec to the front', () => {
             const sdp = SampleSdpStrings.multiCodecVideoSdp;
             const videoMLine = sdp.media.find(m => m.type === 'video');
 
-            SDPUtil.preferVideoCodec(videoMLine, 'H264');
+            SDPUtil.preferCodec(videoMLine, 'H264');
             const newPayloadTypesOrder
                 = videoMLine.payloads.split(' ').map(
                     ptStr => parseInt(ptStr, 10));
 
-            expect(newPayloadTypesOrder[0]).toEqual(126);
+            expect(newPayloadTypesOrder[0]).toEqual(102);
+            expect(newPayloadTypesOrder[1]).toEqual(127);
         });
     });
 
-    describe('stripVideoCodec', () => {
-        it('should remove a codec', () => {
+    describe('preferCodec for audio codec', () => {
+        it('should move a preferred audio codec to the front', () => {
+            const sdp = SampleSdpStrings.multiCodecVideoSdp;
+            const audioMLine = sdp.media.find(m => m.type === 'audio');
+
+            SDPUtil.preferCodec(audioMLine, 'ISAC');
+            const newPayloadTypesOrder
+                = audioMLine.payloads.split(' ').map(
+                    ptStr => parseInt(ptStr, 10));
+
+            expect(newPayloadTypesOrder[0]).toEqual(103);
+            expect(newPayloadTypesOrder[1]).toEqual(104);
+        });
+    });
+
+    describe('strip Video Codec', () => {
+        it('should remove a video codec', () => {
             const sdp = SampleSdpStrings.multiCodecVideoSdp;
             const videoMLine = sdp.media.find(m => m.type === 'video');
 
-            SDPUtil.stripVideoCodec(videoMLine, 'H264');
+            SDPUtil.stripCodec(videoMLine, 'H264');
             const newPayloadTypes = videoMLine.payloads.split(' ').map(Number);
 
-            expect(newPayloadTypes.length).toEqual(1);
-            expect(newPayloadTypes[0]).toEqual(100);
+            expect(newPayloadTypes.length).toEqual(4);
+            expect(newPayloadTypes[0]).toEqual(96);
+        });
+    });
+
+    describe('strip Audio Codec', () => {
+        it('should remove an audio codec', () => {
+            const sdp = SampleSdpStrings.multiCodecVideoSdp;
+            const audioMLine = sdp.media.find(m => m.type === 'audio');
+
+            SDPUtil.stripCodec(audioMLine, 'OPUS');
+            const newPayloadTypes = audioMLine.payloads.split(' ').map(Number);
+
+            expect(newPayloadTypes.length).toEqual(3);
+            expect(newPayloadTypes[0]).toEqual(103);
         });
     });
 });

modules/xmpp/SampleSdpStrings.js

 
 // A basic sdp video mline with a single stream and multiple codecs
 const multiCodecVideoMLine = ''
-+ 'm=video 9 RTP/SAVPF 100 126 97\r\n'
++ 'm=video 9 RTP/SAVPF 96 97 98 99 102 121 127 120\r\n'
 + 'c=IN IP4 0.0.0.0\r\n'
-+ 'a=rtpmap:100 VP8/90000\r\n'
-+ 'a=rtpmap:126 H264/90000\r\n'
-+ 'a=rtpmap:97 H264/90000\r\n'
++ 'a=rtpmap:96 VP8/90000\r\n'
++ 'a=rtpmap:97 rtx/90000\r\n'
++ 'a=rtpmap:98 VP9/90000\r\n'
++ 'a=rtpmap:99 rtx/90000\r\n'
++ 'a=rtpmap:102 H264/90000\r\n'
++ 'a=rtpmap:121 rtx/90000\r\n'
++ 'a=rtpmap:127 H264/90000\r\n'
++ 'a=rtpmap:120 rtx/90000\r\n'
 + 'a=rtcp:9 IN IP4 0.0.0.0\r\n'
-+ 'a=rtcp-fb:100 ccm fir\r\n'
-+ 'a=rtcp-fb:100 nack\r\n'
-+ 'a=rtcp-fb:100 nack pli\r\n'
-+ 'a=rtcp-fb:100 goog-remb\r\n'
-+ 'a=fmtp:126 profile-level-id=42e01f;level-asymmetry-allowed=1;packetization-mode=1\r\n'
-+ 'a=fmtp:97 profile-level-id=42e01f;level-asymmetry-allowed=1\r\n'
++ 'a=rtcp-fb:96 ccm fir\r\n'
++ 'a=rtcp-fb:96 transport-cc\r\n'
++ 'a=rtcp-fb:96 nack\r\n'
++ 'a=rtcp-fb:96 nack pli\r\n'
++ 'a=rtcp-fb:96 goog-remb\r\n'
++ 'a=rtcp-fb:98 ccm fir\r\n'
++ 'a=rtcp-fb:98 transport-cc\r\n'
++ 'a=rtcp-fb:98 nack\r\n'
++ 'a=rtcp-fb:98 nack pli\r\n'
++ 'a=rtcp-fb:98 goog-remb\r\n'
++ 'a=rtcp-fb:102 ccm fir\r\n'
++ 'a=rtcp-fb:102 transport-cc\r\n'
++ 'a=rtcp-fb:102 nack\r\n'
++ 'a=rtcp-fb:102 nack pli\r\n'
++ 'a=rtcp-fb:102 goog-remb\r\n'
++ 'a=rtcp-fb:127 ccm fir\r\n'
++ 'a=rtcp-fb:127 transport-cc\r\n'
++ 'a=rtcp-fb:127 nack\r\n'
++ 'a=rtcp-fb:127 nack pli\r\n'
++ 'a=rtcp-fb:127 goog-remb\r\n'
++ 'a=fmtp:97 apt=96\r\n'
++ 'a=fmtp:98 profile-id=0\r\n'
++ 'a=fmtp:102 profile-level-id=42e01f;level-asymmetry-allowed=1;packetization-mode=1\r\n'
++ 'a=fmtp:121 apt=102\r\n'
++ 'a=fmtp:127 profile-level-id=42e01f;level-asymmetry-allowed=1:packetization-mode=0\r\n'
++ 'a=fmtp:120 apt=127\r\n'
 + 'a=extmap:3 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time\r\n'
 + 'a=setup:passive\r\n'
 + 'a=mid:video\r\n'