feat(multi-stream-support) Handle SDP munging for multiple local/remote streams per ep. (#1868)

* feat(multi-stream-support) Handle SDP munging for multiple local/remote streams/ep.
A new SDPSimulcast class is added for handling SDP munging for local and remote descriptions to handle multiple streams for both local and remote endpoints. This new class will be used only for unified plan implentation. The sdp-simucast npm package will be used for plan-b and deprecated later when all the clients switch to unified plan.

* fix(build) fix building with TS code

Use the Babel preset for the webpack bundle since Babel 7 already
understands TS and ts-loader uses tsc instead, which we configure
differently.

* squash: Add unit test and address review comments.

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

modules/RTC/TraceablePeerConnection.js

@@ -17,6 +17,7 @@ import RtxModifier from '../sdp/RtxModifier';
 import SDP from '../sdp/SDP';
 import SDPUtil from '../sdp/SDPUtil';
 import SdpConsistency from '../sdp/SdpConsistency';
+import SdpSimulcast from '../sdp/SdpSimulcast.ts';
 import { SdpTransformWrap } from '../sdp/SdpTransformUtil';
 import * as GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 
@@ -260,14 +261,20 @@ export default function TraceablePeerConnection(
     this.maxstats = options.maxstats;
 
     this.interop = new Interop();
-    const Simulcast = require('@jitsi/sdp-simulcast');
 
-    this.simulcast = new Simulcast(
-        {
-            numOfLayers: SIM_LAYER_RIDS.length,
-            explodeRemoteSimulcast: false,
-            usesUnifiedPlan: this._usesUnifiedPlan
-        });
+    if (this._usesUnifiedPlan) {
+        this.simulcast = new SdpSimulcast({ numOfLayers: SIM_LAYER_RIDS.length });
+    } else {
+        const Simulcast = require('@jitsi/sdp-simulcast');
+
+        this.simulcast = new Simulcast(
+            {
+                numOfLayers: SIM_LAYER_RIDS.length,
+                explodeRemoteSimulcast: false,
+                usesUnifiedPlan: false
+            });
+    }
+
     this.sdpConsistency = new SdpConsistency(this.toString());
 
     /**

modules/sdp/SDPSimulcast.spec.js

@@ -0,0 +1,157 @@
+import * as transform from 'sdp-transform';
+
+import * as MediaType from '../../service/RTC/MediaType';
+
+import { default as SampleSdpStrings } from './SampleSdpStrings.js';
+import SdpSimulcast from './SdpSimulcast.ts';
+
+
+const getVideoGroups = (parsedSdp, groupSemantics) => {
+    const videoMLine = parsedSdp.media.find(m => m.type === MediaType.VIDEO);
+
+    videoMLine.ssrcGroups = videoMLine.ssrcGroups || [];
+
+    return videoMLine.ssrcGroups.filter(g => g.semantics === groupSemantics);
+};
+
+const numVideoSsrcs = parsedSdp => {
+    const videoMLine = parsedSdp.media.find(m => m.type === MediaType.VIDEO);
+    const ssrcs = new Set(videoMLine.ssrcs?.map(ssrcInfo => ssrcInfo.id));
+
+    return ssrcs.size;
+};
+
+const parseSimLayers = parsedSdp => {
+    const videoMLine = parsedSdp.media.find(m => m.type === MediaType.VIDEO);
+    const simGroup = videoMLine.ssrcGroups?.find(group => group.semantics === 'SIM');
+
+    if (simGroup) {
+        return simGroup.ssrcs.split(' ').map(ssrc => parseInt(ssrc, 10));
+    }
+
+    return null;
+};
+
+describe('sdp-simulcast', () => {
+    const numLayers = 3;
+    let simulcast;
+
+    beforeEach(() => {
+        simulcast = new SdpSimulcast({ numOfLayers: numLayers });
+    });
+
+    describe('mungeLocalDescription', () => {
+        it('should add simulcast layers to the local sdp', () => {
+            const sdp = SampleSdpStrings.plainVideoSdp;
+            const desc = {
+                type: 'answer',
+                sdp: transform.write(sdp)
+            };
+
+            const newDesc = simulcast.mungeLocalDescription(desc);
+            const newSdp = transform.parse(newDesc.sdp);
+
+            expect(numVideoSsrcs(newSdp)).toEqual(numLayers);
+            const simGroup = getVideoGroups(newSdp, 'SIM')[0];
+
+            expect(simGroup.ssrcs.split(' ').length).toEqual(numLayers);
+        });
+
+        it('should add the cached SSRCs on subsequent sLD calls to the local sdp', () => {
+            const sdp = SampleSdpStrings.plainVideoSdp;
+            const desc = {
+                type: 'answer',
+                sdp: transform.write(sdp)
+            };
+
+            const newDesc = simulcast.mungeLocalDescription(desc);
+            const newSdp = transform.parse(newDesc.sdp);
+            const cachedSsrcs = parseSimLayers(newSdp);
+
+            // Call sLD again with the original description.
+            const secondDesc = simulcast.mungeLocalDescription(desc);
+            const secondSdp = transform.parse(secondDesc.sdp);
+
+            expect(parseSimLayers(secondSdp)).toEqual(cachedSsrcs);
+        });
+
+        describe('corner cases', () => {
+            it('should do nothing if the mline has no ssrcs in the local sdp', () => {
+                const sdp = SampleSdpStrings.plainVideoSdp;
+                const videoMLine = sdp.media.find(m => m.type === MediaType.VIDEO);
+
+                videoMLine.ssrcs = [];
+                const desc = {
+                    type: 'answer',
+                    sdp: transform.write(sdp)
+                };
+
+                const newDesc = simulcast.mungeLocalDescription(desc);
+                const newSdp = transform.parse(newDesc.sdp);
+
+                expect(numVideoSsrcs(newSdp)).toEqual(0);
+            });
+
+            it('should do nothing if the mline already has a SIM group and 3 ssrcs in the local sdp', () => {
+                const sdp = SampleSdpStrings.simulcastSdp;
+                const desc = {
+                    type: 'answer',
+                    sdp: transform.write(sdp)
+                };
+                const ssrcs = parseSimLayers(sdp);
+
+                const newDesc = simulcast.mungeLocalDescription(desc);
+                const newSdp = transform.parse(newDesc.sdp);
+
+                expect(parseSimLayers(newSdp)).toEqual(ssrcs);
+            });
+
+            it('should do nothing if the m-line has only recv-only ssrcs', () => {
+                const sdp = SampleSdpStrings.recvOnlySdp;
+                const desc = {
+                    type: 'answer',
+                    sdp: transform.write(sdp)
+                };
+                const newDesc = simulcast.mungeLocalDescription(desc);
+                const newSdp = transform.parse(newDesc.sdp);
+
+                expect(numVideoSsrcs(newSdp)).toEqual(1);
+            });
+        });
+    });
+
+    describe('mungeRemoteDescription', () => {
+        it('should implode remote simulcast SSRCs into one FID group', () => {
+            const sdp = SampleSdpStrings.simulcastRtxSdp;
+            const desc = {
+                type: 'offer',
+                sdp: transform.write(sdp)
+            };
+            const newDesc = simulcast.mungeRemoteDescription(desc);
+            const newSdp = transform.parse(newDesc.sdp);
+            const fidGroups = getVideoGroups(newSdp, 'FID');
+            const simGroups = getVideoGroups(newSdp, 'SIM');
+
+            expect(fidGroups.length).toEqual(1);
+            expect(simGroups.length).toEqual(0);
+            expect(fidGroups[0].ssrcs).toContain('1757014965');
+            expect(fidGroups[0].ssrcs).toContain('984899560');
+        });
+
+        it('should implode remote simulcast SSRCs without RTX into one primary SSRC', () => {
+            const sdp = SampleSdpStrings.simulcastNoRtxSdp;
+            const desc = {
+                type: 'offer',
+                sdp: transform.write(sdp)
+            };
+            const newDesc = simulcast.mungeRemoteDescription(desc);
+            const newSdp = transform.parse(newDesc.sdp);
+            const fidGroups = getVideoGroups(newSdp, 'FID');
+            const simGroups = getVideoGroups(newSdp, 'SIM');
+
+            expect(fidGroups.length).toEqual(0);
+            expect(simGroups.length).toEqual(0);
+            expect(numVideoSsrcs(newSdp)).toEqual(1);
+        });
+    });
+});

modules/sdp/SampleSdpStrings.js

@@ -185,7 +185,7 @@ const simulcastRtxVideoMLineSdp = ''
 + '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'
-+ 'a=sendrecv\r\n'
++ 'a=sendonly\r\n'
 + 'a=ice-ufrag:adPg\r\n'
 + 'a=ice-pwd:Xsr05Mq8S7CR44DAnusZE26F\r\n'
 + 'a=fingerprint:sha-256 6A:39:DE:11:24:AD:2E:4E:63:D6:69:D3:85:05:53:C7:3C:38:A4:B7:91:74:C0:91:44:FC:94:63:7F:01:AB:A9\r\n'
@@ -371,9 +371,38 @@ const videoLineP2pFF = ''
 + 'a=ssrc:984899560 cname:peDGrDD6WsxUOki/\r\n'
 + 'a=rtcp-mux\r\n';
 
+// An sdp video mline with 3 simulcast streams
+const simulcastVideoMLineNoRtxSdp = ''
++ 'm=video 9 RTP/SAVPF 100\r\n'
++ 'c=IN IP4 0.0.0.0\r\n'
++ 'a=rtpmap:100 VP8/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=extmap:3 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time\r\n'
++ 'a=setup:passive\r\n'
++ 'a=mid:video\r\n'
++ 'a=sendonly\r\n'
++ 'a=ice-ufrag:adPg\r\n'
++ 'a=ice-pwd:Xsr05Mq8S7CR44DAnusZE26F\r\n'
++ 'a=fingerprint:sha-256 6A:39:DE:11:24:AD:2E:4E:63:D6:69:D3:85:05:53:C7:3C:38:A4:B7:91:74:C0:91:44:FC:94:63:7F:01:AB:A9\r\n'
++ 'a=ssrc:1757014965 msid:0836cc8e-a7bb-47e9-affb-0599414bc56d bdbd2c0a-7959-4578-8db5-9a6a1aec4ecf\r\n'
++ 'a=ssrc:1757014965 cname:peDGrDD6WsxUOki/\r\n'
++ 'a=ssrc:1479742055 msid:0836cc8e-a7bb-47e9-affb-0599414bc56d bdbd2c0a-7959-4578-8db5-9a6a1aec4ecf\r\n'
++ 'a=ssrc:1479742055 cname:peDGrDD6WsxUOki/\r\n'
++ 'a=ssrc:1089111804 msid:0836cc8e-a7bb-47e9-affb-0599414bc56d bdbd2c0a-7959-4578-8db5-9a6a1aec4ecf\r\n'
++ 'a=ssrc:1089111804 cname:peDGrDD6WsxUOki/\r\n'
++ 'a=ssrc-group:SIM 1757014965 1479742055 1089111804\r\n'
++ 'a=rtcp-mux\r\n';
+
 // A full sdp string representing a client doing simulcast
 const simulcastSdpStr = baseSessionSdp + baseAudioMLineSdp + simulcastVideoMLineSdp + baseDataMLineSdp;
 
+// A full sdp string representing a remote client doing simucast when RTX is not negotiated with the jvb.
+const simulcastNoRtxSdpStr = baseSessionSdp + baseAudioMLineSdp + simulcastVideoMLineNoRtxSdp;
+
 // A full sdp string representing a client doing simulcast and rtx
 const simulcastRtxSdpStr = baseSessionSdp + baseAudioMLineSdp + simulcastRtxVideoMLineSdp + baseDataMLineSdp;
 
@@ -403,6 +432,10 @@ export default {
         return transform.parse(simulcastSdpStr);
     },
 
+    get simulcastNoRtxSdp() {
+        return transform.parse(simulcastNoRtxSdpStr);
+    },
+
     get simulcastRtxSdp() {
         return transform.parse(simulcastRtxSdpStr);
     },

modules/sdp/SdpSimulcast.ts

@@ -0,0 +1,317 @@
+import MediaDirection from '../../service/RTC/MediaDirection';
+import * as MediaType from '../../service/RTC/MediaType';
+
+import * as transform from 'sdp-transform';
+
+const DEFAULT_NUM_OF_LAYERS = 3;
+
+interface Description {
+    type: RTCSdpType;
+    sdp: string;
+}
+
+interface Options {
+    numOfLayers?: number
+}
+
+/**
+ * This class handles SDP munging for enabling simulcast for local video streams in Unified plan. A set of random SSRCs
+ * are generated for the higher layer streams and they are cached for a given mid. The cached SSRCs are then reused on
+ * the subsequent iterations while munging the local description. This class also handles imploding of the simulcast
+ * SSRCs for remote endpoints into the primary FID group in remote description since Jicofo signals all SSRCs relevant
+ * to a given endpoint.
+ */
+export default class SdpSimulcast {
+    private _options: Options;
+    private _ssrcCache: Map<string, Array<number>>;
+
+    /**
+     * Creates a new instance.
+     *
+     * @param options
+     */
+    constructor(options: Options) {
+        this._options = options;
+        this._ssrcCache = new Map();
+
+        if (!this._options.numOfLayers) {
+            this._options.numOfLayers = DEFAULT_NUM_OF_LAYERS;
+        }
+    }
+
+    /**
+     * Updates the given media description using the SSRCs that were cached for the mid associated
+     * with the media description and returns the modified media description.
+     *
+     * @param mLine
+     * @returns
+     */
+     _fillSsrcsFromCache(mLine: transform.MediaDescription) : any {
+        const mid = mLine.mid;
+        const cachedSsrcs = this._ssrcCache.get(mid);
+        const newSsrcs = this._parseSimLayers(mLine);
+        const newMsid = this._getSsrcAttribute(mLine, newSsrcs[0], 'msid');
+        const newCname = this._getSsrcAttribute(mLine, newSsrcs[0], 'cname');
+
+        mLine.ssrcs = [];
+        mLine.ssrcGroups = [];
+
+        for (const ssrc of cachedSsrcs) {
+            mLine.ssrcs.push({
+                id: ssrc,
+                attribute: 'msid',
+                value: newMsid
+            });
+            mLine.ssrcs.push({
+                id: ssrc,
+                attribute: 'cname',
+                value: newCname
+            });
+        }
+
+        mLine.ssrcGroups.push({
+            semantics: 'SIM',
+            ssrcs: cachedSsrcs.join(' ')
+        });
+
+        return mLine;
+    }
+
+    /**
+     * Generates a new set of SSRCs for the higher simulcast layers/streams and adds the attributes and SIM group to
+     * the given media description and returns the modified media description.
+     *
+     * @param mLine
+     * @param primarySsrc
+     * @returns
+     */
+    _generateNewSsrcsForSimulcast(mLine: transform.MediaDescription, primarySsrc: number) : any {
+        const cname = this._getSsrcAttribute(mLine, primarySsrc, 'cname');
+        let msid = this._getSsrcAttribute(mLine, primarySsrc, 'msid');
+        const addAssociatedAttributes = (mLine: transform.MediaDescription, ssrc: number) => {
+            mLine.ssrcs.push({
+                id: ssrc,
+                attribute: 'cname',
+                value: cname
+            });
+            mLine.ssrcs.push({
+                id: ssrc,
+                attribute: 'msid',
+                value: msid
+            });
+        }
+
+        // In Unified-plan mode, the a=ssrc lines with the msid attribute are not present (only cname attributes are
+        // present) in the answers that Chrome and Safari generate for an offer received from Jicofo. Generate these
+        // a=ssrc lines using the msid values from the a=msid line.
+        if (!msid) {
+            msid = mLine.msid;
+            const primarySsrcs = mLine.ssrcs;
+
+            primarySsrcs.forEach(ssrc => {
+                mLine.ssrcs.push({
+                    id: ssrc.id,
+                    attribute: 'msid',
+                    value: msid
+                });
+            })
+        }
+
+        // Generate SIM layers.
+        const simSsrcs = [];
+    
+        for (let i = 0; i < this._options.numOfLayers - 1; ++i) {
+            const simSsrc = this._generateSsrc();
+
+            addAssociatedAttributes(mLine, simSsrc);
+            simSsrcs.push(simSsrc);
+        }
+
+        mLine.ssrcGroups = mLine.ssrcGroups || [];
+        mLine.ssrcGroups.push({
+            semantics: 'SIM',
+            ssrcs: primarySsrc + ' ' + simSsrcs.join(' ')
+        });
+    
+        return mLine;
+    }
+
+    /**
+     * Returns a random number to be used for the SSRC.
+     *
+     * @returns
+     */
+    _generateSsrc() : number {
+        const max = 0xffffffff;
+
+        return Math.floor(Math.random() * max);
+    }
+
+    /**
+     * Returns the requested attribute value for a SSRC from a given media description.
+     *
+     * @param mLine
+     * @param ssrc
+     * @param attributeName
+     * @returns
+     */
+    _getSsrcAttribute(mLine: transform.MediaDescription, ssrc: number, attributeName: string) : string | undefined {
+        return mLine.ssrcs?.find(
+            ssrcInfo => Number(ssrcInfo.id) === ssrc
+            && ssrcInfo.attribute === attributeName)?.value;
+    }
+
+    /**
+     * Returns an array of all the primary SSRCs in the SIM group for a given media description.
+     *
+     * @param mLine
+     * @returns
+     */
+    _parseSimLayers(mLine: transform.MediaDescription) : Array<number> | null {
+        const simGroup = mLine.ssrcGroups?.find(group => group.semantics === 'SIM');
+
+        if (simGroup) {
+            return simGroup.ssrcs.split(' ').map(ssrc => Number(ssrc));
+        }
+
+        if (mLine.ssrcs?.length) {
+            return [ Number(mLine.ssrcs[0].id) ];
+        }
+
+        return null;
+    }
+
+    /**
+     * Munges the given media description to enable simulcast for the video media sections that are in either have
+     * SENDRECV or SENDONLY as the media direction thereby ignoring all the RECVONLY transceivers created for remote
+     * endpoints.
+     * NOTE: This needs to be called only when simulcast is enabled.
+     *
+     * @param description
+     * @returns
+     */
+    mungeLocalDescription(description: Description) : Description {
+        if (!description || !description.sdp) {
+            return description;
+        }
+        const session = transform.parse(description.sdp);
+
+        for (let media of session.media) {
+            // Ignore recvonly and inactive transceivers created for remote sources.
+            if (media.direction === MediaDirection.RECVONLY || media.direction === MediaDirection.INACTIVE) {
+                continue;
+            }
+
+            // Ignore audio m-lines.
+            if (media.type !== MediaType.VIDEO) {
+                continue;
+            }
+            const mid = media.mid;
+            const numSsrcs = new Set(media.ssrcs?.map(ssrcInfo => ssrcInfo.id));
+            const numGroups = media.ssrcGroups?.length ?? 0;
+            let primarySsrc: number;
+
+            // Do not munge if the description has no ssrcs or if simulcast is already enabled.
+            if (numSsrcs.size === 0 || numSsrcs.size > 2 || (numSsrcs.size === 2 && numGroups === 0)) {
+                continue;
+            }
+            if (numSsrcs.size === 1) {
+                primarySsrc = Number(media.ssrcs[0]?.id);
+            } else {
+                const fidGroup = media.ssrcGroups.find(group => group.semantics === 'FID');
+
+                if (fidGroup) {
+                    primarySsrc = Number(fidGroup.ssrcs.split(' ')[0]);
+                }
+            }
+
+            if (this._ssrcCache.has(mid)) {
+                media = this._fillSsrcsFromCache(media);
+            } else {
+                media = this._generateNewSsrcsForSimulcast(media, primarySsrc);
+                const simulcastSsrcs = this._parseSimLayers(media);
+
+                // Update the SSRCs in the cache so that they can re-used for the same mid again.
+                this._ssrcCache.set(mid, simulcastSsrcs);
+            }
+        }
+
+        return new RTCSessionDescription({
+            type: description.type,
+            sdp: transform.write(session)
+        });
+    }
+
+    /**
+     * Munges the given media description by removing the SSRCs and related FID groups for the higher layer streams.
+     *
+     * @param description
+     * @returns
+     */
+    mungeRemoteDescription(description: Description) : Description {
+        if (!description || !description.sdp) {
+            return description;
+        }
+
+        const session = transform.parse(description.sdp);
+
+        for (const media of session.media) {
+            if (media.type !== MediaType.VIDEO) {
+                continue;
+            }
+
+            if (media.direction !== MediaDirection.SENDONLY) {
+                continue;
+            }
+
+            // Ignore m-lines that do not have any SSRCs or SSRC groups. These are the ones associated with remote
+            // sources that have left the call. These will be recycled when a new remote source joins the call.
+            if (!media.ssrcGroups?.length || !media?.ssrcs.length) {
+                continue;
+            }
+
+            // Cache the SSRCs and the source groups.
+            const mungedSsrcs = new Set(media.ssrcs.slice());
+            const mungedSsrcGroups = new Set(media.ssrcGroups.slice());
+            const fidGroups = media.ssrcGroups.filter(group => group.semantics === 'FID');
+            const simGroup = media.ssrcGroups.find(group => group.semantics === 'SIM');
+            const primarySsrc = simGroup?.ssrcs.split(' ')[0];;
+
+            // When simulcast and RTX are both enabled.
+            if (fidGroups.length && simGroup) {
+                const fidGroup = fidGroups.find(group => group.ssrcs.includes(primarySsrc));
+                const secondarySsrc = fidGroup.ssrcs.split(' ')[1];
+
+                for (const ssrcGroup of media.ssrcGroups) {
+                    if (ssrcGroup !== fidGroup) {
+                        mungedSsrcGroups.delete(ssrcGroup);
+                    }
+                }
+                for (const ssrc of media.ssrcs) {
+                    if (ssrc.id.toString() !== primarySsrc
+                        && ssrc.id.toString() !== secondarySsrc) {
+                        mungedSsrcs.delete(ssrc);
+                    }
+                }
+
+            // When simulcast is enabled but RTX is disabled.
+            } else if (simGroup) {
+                mungedSsrcGroups.delete(simGroup);
+
+                for (const ssrc of media.ssrcs) {
+                    if (ssrc.id.toString() !== primarySsrc) {
+                        mungedSsrcs.delete(ssrc);
+                    }
+                }
+            }
+
+            media.ssrcs = Array.from(mungedSsrcs);
+            media.ssrcGroups = Array.from(mungedSsrcGroups);
+        }
+
+        return new RTCSessionDescription ({
+            type: description.type,
+            sdp: transform.write(session)
+        });
+    }
+}

package.json

@@ -38,7 +38,9 @@
     "@babel/core": "7.16.0",
     "@babel/eslint-parser": "7.16.0",
     "@babel/preset-env": "7.16.0",
+    "@babel/preset-typescript": "7.16.7",
     "@jitsi/eslint-config": "4.0.0",
+    "@types/sdp-transform": "2.4.5",
     "babel-loader": "8.2.3",
     "core-js": "3.19.1",
     "eslint": "8.1.0",
@@ -51,7 +53,6 @@
     "karma-webpack": "5.0.0",
     "process": "0.11.10",
     "string-replace-loader": "3.0.3",
-    "ts-loader": "9.2.5",
     "typescript": "4.3.5",
     "webpack": "5.57.1",
     "webpack-bundle-analyzer": "4.4.2",
@@ -69,6 +70,11 @@
   },
   "browser": "dist/umd/lib-jitsi-meet.min.js",
   "module": "dist/esm/JitsiMeetJS.js",
-  "files": [ "dist", "types", "connection_optimization/external_connect.js", "modules/browser/capabilities.json" ],
+  "files": [
+    "dist",
+    "types",
+    "connection_optimization/external_connect.js",
+    "modules/browser/capabilities.json"
+  ],
   "license": "Apache-2.0"
 }

tsconfig.json

@@ -8,6 +8,7 @@
     "allowJs": true,
     "skipLibCheck": true,
     "esModuleInterop": true,
+    "moduleResolution": "node",
     "allowSyntheticDefaultImports": true,
     "lib": [
       "esnext",

types/auto/modules/sdp/SdpSimulcast.d.ts

@@ -0,0 +1,82 @@
+import * as transform from 'sdp-transform';
+interface Description {
+    type: RTCSdpType;
+    sdp: string;
+}
+interface Options {
+    numOfLayers?: number;
+}
+/**
+ * This class handles SDP munging for enabling simulcast for local video streams in Unified plan. A set of random SSRCs
+ * are generated for the higher layer streams and they are cached for a given mid. The cached SSRCs are then reused on
+ * the subsequent iterations while munging the local description. This class also handles imploding of the simulcast
+ * SSRCs for remote endpoints into the primary FID group in remote description since Jicofo signals all SSRCs relevant
+ * to a given endpoint.
+ */
+export default class SdpSimulcast {
+    private _options;
+    private _ssrcCache;
+    /**
+     * Creates a new instance.
+     *
+     * @param options
+     */
+    constructor(options: Options);
+    /**
+     * Updates the given media description using the SSRCs that were cached for the mid associated
+     * with the media description and returns the modified media description.
+     *
+     * @param mLine
+     * @returns
+     */
+    _fillSsrcsFromCache(mLine: transform.MediaDescription): any;
+    /**
+     * Generates a new set of SSRCs for the higher simulcast layers/streams and adds the attributes and SIM group to
+     * the given media description and returns the modified media description.
+     *
+     * @param mLine
+     * @param primarySsrc
+     * @returns
+     */
+    _generateNewSsrcsForSimulcast(mLine: transform.MediaDescription, primarySsrc: number): any;
+    /**
+     * Returns a random number to be used for the SSRC.
+     *
+     * @returns
+     */
+    _generateSsrc(): number;
+    /**
+     * Returns the requested attribute value for a SSRC from a given media description.
+     *
+     * @param mLine
+     * @param ssrc
+     * @param attributeName
+     * @returns
+     */
+    _getSsrcAttribute(mLine: transform.MediaDescription, ssrc: number, attributeName: string): string | undefined;
+    /**
+     * Returns an array of all the primary SSRCs in the SIM group for a given media description.
+     *
+     * @param mLine
+     * @returns
+     */
+    _parseSimLayers(mLine: transform.MediaDescription): Array<number> | null;
+    /**
+     * Munges the given media description to enable simulcast for the video media sections that are in either have
+     * SENDRECV or SENDONLY as the media direction thereby ignoring all the RECVONLY transceivers created for remote
+     * endpoints.
+     * NOTE: This needs to be called only when simulcast is enabled.
+     *
+     * @param description
+     * @returns
+     */
+    mungeLocalDescription(description: Description): Description;
+    /**
+     * Munges the given media description by removing the SSRCs and related FID groups for the higher layer streams.
+     *
+     * @param description
+     * @returns
+     */
+    mungeRemoteDescription(description: Description): Description;
+}
+export {};

types/auto/modules/sdp/SdpTransformUtil.d.ts

@@ -33,7 +33,7 @@ export class SdpTransformWrap {
      * @param {string} rawSDP the SDP in raw text format.
      */
     constructor(rawSDP: string);
-    parsedSDP: any;
+    parsedSDP: transform.SessionDescription;
     /**
      * Selects all the m-lines from the SDP for a given media type.
      *
@@ -50,6 +50,7 @@ export class SdpTransformWrap {
      */
     toRawSDP(): string;
 }
+import * as transform from "sdp-transform";
 /**
  * A wrapper around 'sdp-transform' media description object which provides
  * utility methods for common SDP/SSRC related operations.

webpack-shared-config.js

@@ -9,6 +9,9 @@ module.exports = (minimize, analyzeBundle) => {
     return {
         // The inline-source-map is used to allow debugging the unit tests with Karma
         devtool: minimize ? 'source-map' : 'inline-source-map',
+        resolve: {
+            extensions: [ '', '.js', '.ts' ]
+        },
         mode: minimize ? 'production' : 'development',
         module: {
             rules: [ {
@@ -49,14 +52,11 @@ module.exports = (minimize, analyzeBundle) => {
                                     safari: 14
                                 }
                             }
-                        ]
+                        ],
+                        '@babel/preset-typescript'
                     ]
                 },
                 test: /\.(js|ts)$/
-            }, {
-                exclude: /node_modules/,
-                test: /\.ts$/,
-                use: 'ts-loader'
             } ]
         },
         node: {