werift 0.14.5 → 0.15.0

package/lib/webrtc/src/peerConnection.js

@@ -24,7 +24,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultPeerConfig = exports.findCodecByMimeType = exports.allocateMid = exports.addTransportDescription = exports.createMediaDescriptionForSctp = exports.createMediaDescriptionForTransceiver = exports.RTCPeerConnection = void 0;
 const debug_1 = __importDefault(require("debug"));
-const lodash_1 = require("lodash");
+const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+const isEqual_1 = __importDefault(require("lodash/isEqual"));
 const rx_mini_1 = __importDefault(require("rx.mini"));
 const uuid = __importStar(require("uuid"));
 const _1 = require(".");
@@ -44,11 +45,11 @@ const sctp_1 = require("./transport/sctp");
 const utils_1 = require("./utils");
 const log = (0, debug_1.default)("werift:packages/webrtc/src/peerConnection.ts");
 class RTCPeerConnection extends helper_1.EventTarget {
-    constructor({ codecs, headerExtensions, iceServers, iceTransportPolicy, icePortRange, dtls, } = {}) {
+    constructor({ codecs, headerExtensions, iceServers, iceTransportPolicy, icePortRange, dtls, bundlePolicy, } = {}) {
         super();
         this.cname = uuid.v4();
         this.masterTransportEstablished = false;
-        this.configuration = (0, lodash_1.cloneDeep)(exports.defaultPeerConfig);
+        this.configuration = (0, cloneDeep_1.default)(exports.defaultPeerConfig);
         this.connectionState = "new";
         this.iceConnectionState = "new";
         this.iceGatheringState = "new";
@@ -61,11 +62,6 @@ class RTCPeerConnection extends helper_1.EventTarget {
         this.connectionStateChange = new rx_mini_1.default();
         this.onDataChannel = new rx_mini_1.default();
         this.onRemoteTransceiverAdded = new rx_mini_1.default();
-        /**
-         * should use onRemoteTransceiverAdded
-         * @deprecated
-         */
-        this.onTransceiver = new rx_mini_1.default();
         this.onTransceiverAdded = new rx_mini_1.default();
         this.onIceCandidate = new rx_mini_1.default();
         this.onNegotiationneeded = new rx_mini_1.default();
@@ -148,12 +144,24 @@ class RTCPeerConnection extends helper_1.EventTarget {
                     break;
             }
         });
-        const { iceTransport, dtlsTransport } = this.createTransport([
-            const_1.SRTP_PROFILE.SRTP_AEAD_AES_128_GCM,
-            const_1.SRTP_PROFILE.SRTP_AES128_CM_HMAC_SHA1_80,
-        ]);
-        this.iceTransport = iceTransport;
-        this.dtlsTransport = dtlsTransport;
+        if (bundlePolicy) {
+            this.configuration.bundlePolicy = bundlePolicy;
+        }
+    }
+    get dtlsTransports() {
+        const transports = this.transceivers.map((t) => t.dtlsTransport);
+        if (this.sctpTransport) {
+            transports.push(this.sctpTransport.dtlsTransport);
+        }
+        return transports.reduce((acc, cur) => {
+            if (!acc.map((d) => d.id).includes(cur.id)) {
+                acc.push(cur);
+            }
+            return acc;
+        }, []);
+    }
+    get iceTransports() {
+        return this.dtlsTransports.map((d) => d.iceTransport);
     }
     get localDescription() {
         if (!this._localDescription)
@@ -178,9 +186,7 @@ class RTCPeerConnection extends helper_1.EventTarget {
         return this.transceivers.find((transceiver) => transceiver.mLineIndex === index);
     }
     async createOffer() {
-        if (this.certificates.length === 0) {
-            await this.dtlsTransport.setupCertificate();
-        }
+        await this.ensureCerts();
         this.transceivers.forEach((transceiver) => {
             transceiver.codecs = this.configuration.codecs[transceiver.kind];
             transceiver.headerExtensions =
@@ -222,11 +228,13 @@ class RTCPeerConnection extends helper_1.EventTarget {
             !description.media.find((m) => this.sctpTransport.mid === m.rtp.muxId)) {
             description.media.push(createMediaDescriptionForSctp(this.sctpTransport, allocateMid(this.seenMid)));
         }
-        const mids = description.media
-            .map((m) => m.rtp.muxId)
-            .filter((v) => v);
-        const bundle = new sdp_1.GroupDescription("BUNDLE", mids);
-        description.group.push(bundle);
+        if (this.configuration.bundlePolicy !== "disable") {
+            const mids = description.media
+                .map((m) => m.rtp.muxId)
+                .filter((v) => v);
+            const bundle = new sdp_1.GroupDescription("BUNDLE", mids);
+            description.group.push(bundle);
+        }
         return description.toJSON();
     }
     createDataChannel(label, options = {}) {
@@ -252,7 +260,8 @@ class RTCPeerConnection extends helper_1.EventTarget {
             ordered: settings.ordered,
             protocol: settings.protocol,
         });
-        return new dataChannel_1.RTCDataChannel(this.sctpTransport, parameters);
+        const channel = new dataChannel_1.RTCDataChannel(this.sctpTransport, parameters);
+        return channel;
     }
     removeTrack(sender) {
         if (this.isClosed)
@@ -277,20 +286,31 @@ class RTCPeerConnection extends helper_1.EventTarget {
         this.needNegotiation();
     }
     createTransport(srtpProfiles = []) {
+        const [existing] = this.iceTransports;
+        // Gather ICE candidates for only one track. If the remote endpoint is not bundle-aware, negotiate only one media track.
+        // https://w3c.github.io/webrtc-pc/#rtcbundlepolicy-enum
+        if (this.configuration.bundlePolicy === "max-bundle") {
+            if (existing) {
+                return this.dtlsTransports[0];
+            }
+        }
         const iceGatherer = new ice_1.RTCIceGatherer({
             ...(0, utils_1.parseIceServers)(this.configuration.iceServers),
             forceTurn: this.configuration.iceTransportPolicy === "relay",
             portRange: this.configuration.icePortRange,
         });
-        iceGatherer.onGatheringStateChange.subscribe((state) => {
-            this.updateIceGatheringState(state);
+        if (existing) {
+            iceGatherer.connection.localUserName = existing.connection.localUserName;
+            iceGatherer.connection.localPassword = existing.connection.localPassword;
+        }
+        iceGatherer.onGatheringStateChange.subscribe(() => {
+            this.updateIceGatheringState();
         });
-        this.updateIceGatheringState(iceGatherer.gatheringState);
+        this.updateIceGatheringState();
         const iceTransport = new ice_1.RTCIceTransport(iceGatherer);
-        iceTransport.onStateChange.subscribe((state) => {
-            this.updateIceConnectionState(state);
+        iceTransport.onStateChange.subscribe(() => {
+            this.updateIceConnectionState();
         });
-        this.updateIceConnectionState(iceTransport.state);
         iceTransport.iceGather.onIceCandidate = (candidate) => {
             if (!this.localDescription)
                 return;
@@ -302,7 +322,6 @@ class RTCPeerConnection extends helper_1.EventTarget {
             }
             candidate.sdpMLineIndex = 0;
             candidate.sdpMid = media.rtp.muxId;
-            // for chrome & firefox & maybe others
             candidate.foundation = "candidate:" + candidate.foundation;
             this.onIceCandidate.execute(candidate.toJSON());
             if (this.onicecandidate)
@@ -310,10 +329,15 @@ class RTCPeerConnection extends helper_1.EventTarget {
             this.emit("icecandidate", { candidate });
         };
         const dtlsTransport = new dtls_1.RTCDtlsTransport(iceTransport, this.router, this.certificates, srtpProfiles);
-        return { dtlsTransport, iceTransport };
+        return dtlsTransport;
     }
     createSctpTransport() {
-        const sctp = new sctp_1.RTCSctpTransport(this.dtlsTransport);
+        const dtlsTransport = this.createTransport([
+            const_1.SRTP_PROFILE.SRTP_AEAD_AES_128_GCM,
+            const_1.SRTP_PROFILE.SRTP_AES128_CM_HMAC_SHA1_80,
+        ]);
+        const sctp = new sctp_1.RTCSctpTransport();
+        sctp.setDtlsTransport(dtlsTransport);
         sctp.mid = undefined;
         sctp.onDataChannel.subscribe((channel) => {
             this.onDataChannel.execute(channel);
@@ -322,6 +346,8 @@ class RTCPeerConnection extends helper_1.EventTarget {
                 this.ondatachannel(event);
             this.emit("datachannel", event);
         });
+        this.sctpTransport = sctp;
+        this.updateIceConnectionState();
         return sctp;
     }
     async setLocalDescription(sessionDescription) {
@@ -339,9 +365,6 @@ class RTCPeerConnection extends helper_1.EventTarget {
         // # assign MID
         description.media.forEach((media, i) => {
             const mid = media.rtp.muxId;
-            if (!mid) {
-                throw new Error("mid not exist");
-            }
             this.seenMid.add(mid);
             if (["audio", "video"].includes(media.kind)) {
                 const transceiver = this.getTransceiverByMLineIndex(i);
@@ -353,26 +376,30 @@ class RTCPeerConnection extends helper_1.EventTarget {
                 this.sctpTransport.mid = mid;
             }
         });
-        // # set ICE role
-        if (description.type === "offer") {
-            this.iceTransport.connection.iceControlling = true;
-        }
-        else {
-            this.iceTransport.connection.iceControlling = false;
-        }
-        // One agent full, one lite:  The full agent MUST take the controlling role, and the lite agent MUST take the controlled role
-        // RFC 8445 S6.1.1
-        if (this.iceTransport.connection.remoteIsLite) {
-            this.iceTransport.connection.iceControlling = true;
-        }
-        // # set DTLS role for mediasoup
-        if (description.type === "answer") {
-            const role = description.media.find((media) => media.dtlsParams)
-                ?.dtlsParams?.role;
-            if (role) {
-                this.dtlsTransport.role = role;
+        const setupRole = (dtlsTransport) => {
+            const iceTransport = dtlsTransport.iceTransport;
+            // # set ICE role
+            if (description.type === "offer") {
+                iceTransport.connection.iceControlling = true;
             }
-        }
+            else {
+                iceTransport.connection.iceControlling = false;
+            }
+            // One agent full, one lite:  The full agent MUST take the controlling role, and the lite agent MUST take the controlled role
+            // RFC 8445 S6.1.1
+            if (iceTransport.connection.remoteIsLite) {
+                iceTransport.connection.iceControlling = true;
+            }
+            // # set DTLS role for mediasoup
+            if (description.type === "answer") {
+                const role = description.media.find((media) => media.dtlsParams)
+                    ?.dtlsParams?.role;
+                if (role) {
+                    dtlsTransport.role = role;
+                }
+            }
+        };
+        this.dtlsTransports.forEach((d) => setupRole(d));
         // # configure direction
         this.transceivers.forEach((t) => {
             if (["answer", "pranswer"].includes(description.type)) {
@@ -383,10 +410,18 @@ class RTCPeerConnection extends helper_1.EventTarget {
         // for trickle ice
         this.setLocal(description);
         // # gather candidates
-        await this.iceTransport.iceGather.gather();
-        description.media.map((media) => {
-            addTransportDescription(media, this.dtlsTransport);
+        for (const iceTransport of this.iceTransports) {
+            await iceTransport.iceGather.gather();
+        }
+        description.media
+            .filter((m) => ["audio", "video"].includes(m.kind))
+            .forEach((m, i) => {
+            addTransportDescription(m, this.transceivers[i].dtlsTransport);
         });
+        const sctpMedia = description.media.find((m) => m.kind === "application");
+        if (this.sctpTransport && sctpMedia) {
+            addTransportDescription(sctpMedia, this.sctpTransport.dtlsTransport);
+        }
         this.setLocal(description);
         // connect transports
         if (description.type === "answer") {
@@ -412,33 +447,36 @@ class RTCPeerConnection extends helper_1.EventTarget {
     }
     async addIceCandidate(candidateMessage) {
         const candidate = ice_1.IceCandidate.fromJSON(candidateMessage);
-        await this.iceTransport.addRemoteCandidate(candidate);
+        for (const iceTransport of this.iceTransports) {
+            await iceTransport.addRemoteCandidate(candidate);
+        }
     }
     async connect() {
         if (this.masterTransportEstablished)
             return;
-        const dtlsTransport = this.dtlsTransport;
-        const iceTransport = dtlsTransport.iceTransport;
         this.setConnectionState("connecting");
-        await iceTransport.start().catch((err) => {
-            log("iceTransport.start failed", err);
-            throw err;
-        });
-        log("ice connected");
-        await dtlsTransport.start().catch((err) => {
-            log("dtlsTransport.start failed", err);
-            throw err;
-        });
-        log("dtls connected");
-        if (this.sctpTransport && this.sctpRemotePort) {
-            await this.sctpTransport.start(this.sctpRemotePort);
-            await this.sctpTransport.sctp.stateChanged.connected.asPromise();
-        }
-        log("sctp connected");
+        await Promise.all(this.dtlsTransports.map(async (dtlsTransport) => {
+            const { iceTransport } = dtlsTransport;
+            await iceTransport.start().catch((err) => {
+                log("iceTransport.start failed", err);
+                throw err;
+            });
+            await dtlsTransport.start().catch((err) => {
+                log("dtlsTransport.start failed", err);
+                throw err;
+            });
+            if (this.sctpTransport &&
+                this.sctpRemotePort &&
+                this.sctpTransport.dtlsTransport.id === dtlsTransport.id) {
+                await this.sctpTransport.start(this.sctpRemotePort);
+                await this.sctpTransport.sctp.stateChanged.connected.asPromise();
+                log("sctp connected");
+            }
+        }));
         this.masterTransportEstablished = true;
         this.setConnectionState("connected");
     }
-    localRtp(transceiver) {
+    getLocalRtpParams(transceiver) {
         if (transceiver.mid == undefined)
             throw new Error("mid not assigned");
         const rtp = {
@@ -449,12 +487,7 @@ class RTCPeerConnection extends helper_1.EventTarget {
         };
         return rtp;
     }
-    remoteRtp(remoteDescription, transceiver) {
-        if (transceiver.mLineIndex == undefined)
-            throw new Error("mLineIndex not assigned");
-        const media = remoteDescription.media[transceiver.mLineIndex];
-        if (!media)
-            throw new Error("media line not exist");
+    getRemoteRtpParams(media, transceiver) {
         const receiveParameters = {
             muxId: media.rtp.muxId,
             rtcp: media.rtp.rtcp,
@@ -483,115 +516,79 @@ class RTCPeerConnection extends helper_1.EventTarget {
         const remoteSdp = sdp_1.SessionDescription.parse(sessionDescription.sdp);
         remoteSdp.type = sessionDescription.type;
         this.validateDescription(remoteSdp, false);
+        if (remoteSdp.type === "answer") {
+            this.currentRemoteDescription = remoteSdp;
+            this.pendingRemoteDescription = undefined;
+        }
+        else {
+            this.pendingRemoteDescription = remoteSdp;
+        }
+        const bundle = remoteSdp.group.find((g) => g.semantic === "BUNDLE" && this.configuration.bundlePolicy !== "disable");
+        let bundleTransport;
         // # apply description
-        for (const [i, remoteMedia] of (0, helper_1.enumerate)(remoteSdp.media)) {
+        await Promise.all((0, helper_1.enumerate)(remoteSdp.media).map(async ([i, remoteMedia]) => {
+            let dtlsTransport;
             if (["audio", "video"].includes(remoteMedia.kind)) {
-                const transceiver = this.transceivers.find((t) => t.kind === remoteMedia.kind &&
-                    [undefined, remoteMedia.rtp.muxId].includes(t.mid)) ||
-                    (() => {
-                        // create remote transceiver
-                        const transceiver = this.addTransceiver(remoteMedia.kind, {
-                            direction: "recvonly",
-                        });
-                        this.onRemoteTransceiverAdded.execute(transceiver);
-                        this.onTransceiver.execute(transceiver);
-                        return transceiver;
-                    })();
-                if (!transceiver.mid) {
-                    transceiver.mid = remoteMedia.rtp.muxId;
-                    transceiver.mLineIndex = i;
-                }
-                // # negotiate codecs
-                transceiver.codecs = remoteMedia.rtp.codecs.filter((remoteCodec) => {
-                    const localCodecs = this.configuration.codecs[remoteMedia.kind] || [];
-                    const existCodec = (0, exports.findCodecByMimeType)(localCodecs, remoteCodec);
-                    if (!existCodec)
-                        return false;
-                    if (existCodec?.name.toLowerCase() === "rtx") {
-                        const params = (0, _1.codecParametersFromString)(existCodec.parameters ?? "");
-                        const pt = params["apt"];
-                        const origin = remoteMedia.rtp.codecs.find((c) => c.payloadType === pt);
-                        if (!origin)
-                            return false;
-                        return !!(0, exports.findCodecByMimeType)(localCodecs, origin);
-                    }
-                    return true;
-                });
-                log("negotiated codecs", transceiver.codecs);
-                if (transceiver.codecs.length === 0) {
-                    throw new Error("negotiate codecs failed.");
-                }
-                transceiver.headerExtensions = remoteMedia.rtp.headerExtensions.filter((extension) => (this.configuration.headerExtensions[remoteMedia.kind] || []).find((v) => v.uri === extension.uri));
-                // # configure direction
-                const mediaDirection = remoteMedia.direction || "inactive";
-                const direction = (0, utils_1.reverseDirection)(mediaDirection);
-                if (["answer", "pranswer"].includes(remoteSdp.type)) {
-                    transceiver.currentDirection = direction;
-                }
-                else {
-                    transceiver.offerDirection = direction;
-                }
-                const localParams = this.localRtp(transceiver);
-                transceiver.sender.prepareSend(localParams);
-                if (["recvonly", "sendrecv"].includes(transceiver.direction)) {
-                    const remotePrams = this.remoteRtp(remoteSdp, transceiver);
-                    // register simulcast receiver
-                    remoteMedia.simulcastParameters.forEach((param) => {
-                        this.router.registerRtpReceiverByRid(transceiver, param, remotePrams);
+                let transceiver = this.transceivers.find((t) => t.kind === remoteMedia.kind &&
+                    [undefined, remoteMedia.rtp.muxId].includes(t.mid));
+                if (!transceiver) {
+                    // create remote transceiver
+                    transceiver = this.addTransceiver(remoteMedia.kind, {
+                        direction: "recvonly",
                     });
-                    transceiver.receiver.prepareReceive(remotePrams);
-                    // register ssrc receiver
-                    this.router.registerRtpReceiverBySsrc(transceiver, remotePrams);
+                    this.onRemoteTransceiverAdded.execute(transceiver);
                 }
-                if (["sendonly", "sendrecv"].includes(mediaDirection)) {
-                    // assign msid
-                    if (remoteMedia.msid != undefined) {
-                        const [streamId, trackId] = remoteMedia.msid.split(" ");
-                        transceiver.receiver.remoteStreamId = streamId;
-                        transceiver.receiver.remoteTrackId = trackId;
-                        this.fireOnTrack(transceiver.receiver.track, transceiver, new track_1.MediaStream({
-                            id: streamId,
-                            tracks: [transceiver.receiver.track],
-                        }));
+                if (bundle) {
+                    if (!bundleTransport) {
+                        bundleTransport = transceiver.dtlsTransport;
+                    }
+                    else {
+                        transceiver.setDtlsTransport(bundleTransport);
                     }
                 }
-                transceiver.receiver.setupTWCC(remoteMedia.ssrc[0]?.ssrc);
+                dtlsTransport = transceiver.dtlsTransport;
+                this.setRemoteRTP(transceiver, remoteMedia, remoteSdp.type, i);
             }
             else if (remoteMedia.kind === "application") {
-                // # configure sctp
-                this.sctpRemotePort = remoteMedia.sctpPort;
-                if (!this.sctpRemotePort) {
-                    throw new Error("sctpRemotePort not exist");
-                }
                 if (!this.sctpTransport) {
                     this.sctpTransport = this.createSctpTransport();
                 }
-                this.sctpTransport.setRemotePort(this.sctpRemotePort);
-                if (!this.sctpTransport.mid) {
-                    this.sctpTransport.mid = remoteMedia.rtp.muxId;
+                if (bundle) {
+                    if (!bundleTransport) {
+                        bundleTransport = this.sctpTransport.dtlsTransport;
+                    }
+                    else {
+                        this.sctpTransport.setDtlsTransport(bundleTransport);
+                    }
                 }
+                dtlsTransport = this.sctpTransport.dtlsTransport;
+                this.setRemoteSCTP(remoteMedia, this.sctpTransport);
             }
+            else {
+                throw new Error("invalid media kind");
+            }
+            const iceTransport = dtlsTransport.iceTransport;
             if (remoteMedia.iceParams && remoteMedia.dtlsParams) {
-                this.iceTransport.setRemoteParams(remoteMedia.iceParams);
-                this.dtlsTransport.setRemoteParams(remoteMedia.dtlsParams);
+                iceTransport.setRemoteParams(remoteMedia.iceParams);
+                dtlsTransport.setRemoteParams(remoteMedia.dtlsParams);
                 // One agent full, one lite:  The full agent MUST take the controlling role, and the lite agent MUST take the controlled role
                 // RFC 8445 S6.1.1
                 if (remoteMedia.iceParams?.iceLite) {
-                    this.iceTransport.connection.iceControlling = true;
+                    iceTransport.connection.iceControlling = true;
                 }
             }
             // # add ICE candidates
-            remoteMedia.iceCandidates.forEach(this.iceTransport.addRemoteCandidate);
-            await this.iceTransport.iceGather.gather();
+            remoteMedia.iceCandidates.forEach(iceTransport.addRemoteCandidate);
+            await iceTransport.iceGather.gather();
             if (remoteMedia.iceCandidatesComplete) {
-                await this.iceTransport.addRemoteCandidate(undefined);
+                await iceTransport.addRemoteCandidate(undefined);
             }
             // # set DTLS role
             if (remoteSdp.type === "answer" && remoteMedia.dtlsParams?.role) {
-                this.dtlsTransport.role =
+                dtlsTransport.role =
                     remoteMedia.dtlsParams.role === "client" ? "server" : "client";
             }
-        }
+        }));
         // connect transports
         if (remoteSdp.type === "answer") {
             log("caller start connect");
@@ -606,18 +603,83 @@ class RTCPeerConnection extends helper_1.EventTarget {
         else if (remoteSdp.type === "answer") {
             this.setSignalingState("stable");
         }
-        if (remoteSdp.type === "answer") {
-            this.currentRemoteDescription = remoteSdp;
-            this.pendingRemoteDescription = undefined;
-        }
-        else {
-            this.pendingRemoteDescription = remoteSdp;
-        }
         this.negotiationneeded = false;
         if (this.shouldNegotiationneeded) {
             this.needNegotiation();
         }
     }
+    setRemoteRTP(transceiver, remoteMedia, type, mLineIndex) {
+        if (!transceiver.mid) {
+            transceiver.mid = remoteMedia.rtp.muxId;
+            transceiver.mLineIndex = mLineIndex;
+        }
+        // # negotiate codecs
+        transceiver.codecs = remoteMedia.rtp.codecs.filter((remoteCodec) => {
+            const localCodecs = this.configuration.codecs[remoteMedia.kind] || [];
+            const existCodec = (0, exports.findCodecByMimeType)(localCodecs, remoteCodec);
+            if (!existCodec)
+                return false;
+            if (existCodec?.name.toLowerCase() === "rtx") {
+                const params = (0, _1.codecParametersFromString)(existCodec.parameters ?? "");
+                const pt = params["apt"];
+                const origin = remoteMedia.rtp.codecs.find((c) => c.payloadType === pt);
+                if (!origin)
+                    return false;
+                return !!(0, exports.findCodecByMimeType)(localCodecs, origin);
+            }
+            return true;
+        });
+        log("negotiated codecs", transceiver.codecs);
+        if (transceiver.codecs.length === 0) {
+            throw new Error("negotiate codecs failed.");
+        }
+        transceiver.headerExtensions = remoteMedia.rtp.headerExtensions.filter((extension) => (this.configuration.headerExtensions[remoteMedia.kind] || []).find((v) => v.uri === extension.uri));
+        // # configure direction
+        const mediaDirection = remoteMedia.direction || "inactive";
+        const direction = (0, utils_1.reverseDirection)(mediaDirection);
+        if (["answer", "pranswer"].includes(type)) {
+            transceiver.currentDirection = direction;
+        }
+        else {
+            transceiver.offerDirection = direction;
+        }
+        const localParams = this.getLocalRtpParams(transceiver);
+        transceiver.sender.prepareSend(localParams);
+        if (["recvonly", "sendrecv"].includes(transceiver.direction)) {
+            const remotePrams = this.getRemoteRtpParams(remoteMedia, transceiver);
+            // register simulcast receiver
+            remoteMedia.simulcastParameters.forEach((param) => {
+                this.router.registerRtpReceiverByRid(transceiver, param, remotePrams);
+            });
+            transceiver.receiver.prepareReceive(remotePrams);
+            // register ssrc receiver
+            this.router.registerRtpReceiverBySsrc(transceiver, remotePrams);
+        }
+        if (["sendonly", "sendrecv"].includes(mediaDirection)) {
+            // assign msid
+            if (remoteMedia.msid != undefined) {
+                const [streamId, trackId] = remoteMedia.msid.split(" ");
+                transceiver.receiver.remoteStreamId = streamId;
+                transceiver.receiver.remoteTrackId = trackId;
+                this.fireOnTrack(transceiver.receiver.track, transceiver, new track_1.MediaStream({
+                    id: streamId,
+                    tracks: [transceiver.receiver.track],
+                }));
+            }
+        }
+        transceiver.receiver.setupTWCC(remoteMedia.ssrc[0]?.ssrc);
+    }
+    setRemoteSCTP(remoteMedia, sctpTransport) {
+        // # configure sctp
+        this.sctpRemotePort = remoteMedia.sctpPort;
+        if (!this.sctpRemotePort) {
+            throw new Error("sctpRemotePort not exist");
+        }
+        sctpTransport.setRemotePort(this.sctpRemotePort);
+        if (!sctpTransport.mid) {
+            sctpTransport.mid = remoteMedia.rtp.muxId;
+        }
+    }
     validateDescription(description, isLocal) {
         if (isLocal) {
             if (description.type === "offer") {
@@ -656,7 +718,7 @@ class RTCPeerConnection extends helper_1.EventTarget {
                 throw new Error();
             const offerMedia = offer.media.map((v) => [v.kind, v.rtp.muxId]);
             const answerMedia = description.media.map((v) => [v.kind, v.rtp.muxId]);
-            if (!(0, lodash_1.isEqual)(offerMedia, answerMedia))
+            if (!(0, isEqual_1.default)(offerMedia, answerMedia))
                 throw new Error("Media sections in answer do not match offer");
         }
     }
@@ -674,13 +736,18 @@ class RTCPeerConnection extends helper_1.EventTarget {
     addTransceiver(trackOrKind, options = {}) {
         const kind = typeof trackOrKind === "string" ? trackOrKind : trackOrKind.kind;
         const direction = options.direction || "sendrecv";
-        const sender = new rtpSender_1.RTCRtpSender(trackOrKind, this.dtlsTransport);
-        const receiver = new rtpReceiver_1.RTCRtpReceiver(kind, this.dtlsTransport, sender.ssrc);
-        const transceiver = new rtpTransceiver_1.RTCRtpTransceiver(kind, receiver, sender, direction, this.dtlsTransport);
+        const dtlsTransport = this.createTransport([
+            const_1.SRTP_PROFILE.SRTP_AEAD_AES_128_GCM,
+            const_1.SRTP_PROFILE.SRTP_AES128_CM_HMAC_SHA1_80,
+        ]);
+        const sender = new rtpSender_1.RTCRtpSender(trackOrKind);
+        const receiver = new rtpReceiver_1.RTCRtpReceiver(kind, sender.ssrc);
+        const transceiver = new rtpTransceiver_1.RTCRtpTransceiver(kind, dtlsTransport, receiver, sender, direction);
         transceiver.options = options;
         this.router.registerRtpSender(transceiver.sender);
         this.transceivers.push(transceiver);
         this.onTransceiverAdded.execute(transceiver);
+        this.updateIceConnectionState();
         this.needNegotiation();
         return transceiver;
     }
@@ -735,54 +802,72 @@ class RTCPeerConnection extends helper_1.EventTarget {
             return transceiver.sender;
         }
     }
+    async ensureCerts() {
+        const ensureCert = async (dtlsTransport) => {
+            if (this.certificates.length === 0) {
+                const localCertificate = await dtlsTransport.setupCertificate();
+                this.certificates.push(localCertificate);
+            }
+            else {
+                dtlsTransport.localCertificate = this.certificates[0];
+            }
+        };
+        for (const dtlsTransport of this.dtlsTransports) {
+            await ensureCert(dtlsTransport);
+        }
+    }
     async createAnswer() {
         this.assertNotClosed();
-        if (!["have-remote-offer", "have-local-pranswer"].includes(this.signalingState) ||
-            !this.dtlsTransport)
+        if (!["have-remote-offer", "have-local-pranswer"].includes(this.signalingState)) {
             throw new Error("createAnswer failed");
-        if (this.certificates.length === 0) {
-            await this.dtlsTransport.setupCertificate();
         }
+        if (!this._remoteDescription) {
+            throw new Error("wrong state");
+        }
+        await this.ensureCerts();
         const description = new sdp_1.SessionDescription();
         (0, sdp_1.addSDPHeader)("answer", description);
-        this._remoteDescription?.media.forEach((remoteM) => {
+        this._remoteDescription.media.forEach((remoteMedia) => {
             let dtlsTransport;
             let media;
-            if (["audio", "video"].includes(remoteM.kind)) {
-                const transceiver = this.getTransceiverByMid(remoteM.rtp.muxId);
+            if (["audio", "video"].includes(remoteMedia.kind)) {
+                const transceiver = this.getTransceiverByMid(remoteMedia.rtp.muxId);
                 media = createMediaDescriptionForTransceiver(transceiver, this.cname, (0, utils_1.andDirection)(transceiver.direction, transceiver.offerDirection), transceiver.mid);
-                if (!transceiver.dtlsTransport)
-                    throw new Error();
                 dtlsTransport = transceiver.dtlsTransport;
             }
-            else if (remoteM.kind === "application") {
-                if (!this.sctpTransport || !this.sctpTransport.mid)
-                    throw new Error();
+            else if (remoteMedia.kind === "application") {
+                if (!this.sctpTransport || !this.sctpTransport.mid) {
+                    throw new Error("sctpTransport not found");
+                }
                 media = createMediaDescriptionForSctp(this.sctpTransport, this.sctpTransport.mid);
                 dtlsTransport = this.sctpTransport.dtlsTransport;
             }
-            else
-                throw new Error();
+            else {
+                throw new Error("invalid kind");
+            }
             // # determine DTLS role, or preserve the currently configured role
-            if (!media.dtlsParams)
-                throw new Error();
+            if (!media.dtlsParams) {
+                throw new Error("dtlsParams missing");
+            }
             if (dtlsTransport.role === "auto") {
                 media.dtlsParams.role = "client";
             }
             else {
                 media.dtlsParams.role = dtlsTransport.role;
             }
-            media.simulcastParameters = remoteM.simulcastParameters.map((v) => ({
+            media.simulcastParameters = remoteMedia.simulcastParameters.map((v) => ({
                 ...v,
                 direction: (0, utils_1.reverseSimulcastDirection)(v.direction),
             }));
             description.media.push(media);
         });
-        const bundle = new sdp_1.GroupDescription("BUNDLE", []);
-        description.media.forEach((media) => {
-            bundle.items.push(media.rtp.muxId);
-        });
-        description.group.push(bundle);
+        if (this.configuration.bundlePolicy !== "disable") {
+            const bundle = new sdp_1.GroupDescription("BUNDLE", []);
+            description.media.forEach((media) => {
+                bundle.items.push(media.rtp.muxId);
+            });
+            description.group.push(bundle);
+        }
         return description.toJSON();
     }
     async close() {
@@ -798,26 +883,85 @@ class RTCPeerConnection extends helper_1.EventTarget {
         if (this.sctpTransport) {
             await this.sctpTransport.stop();
         }
-        await this.dtlsTransport.stop();
-        await this.iceTransport.stop();
+        for (const dtlsTransport of this.dtlsTransports) {
+            await dtlsTransport.stop();
+            await dtlsTransport.iceTransport.stop();
+        }
         this.dispose();
         log("peerConnection closed");
     }
     assertNotClosed() {
-        if (this.isClosed)
+        if (this.isClosed) {
             throw new Error("RTCPeerConnection is closed");
+        }
     }
-    updateIceGatheringState(state) {
-        log("iceGatheringStateChange", state);
-        this.iceGatheringState = state;
-        this.iceGatheringStateChange.execute(state);
-        this.emit("icegatheringstatechange", state);
+    // https://w3c.github.io/webrtc-pc/#dom-rtcicegatheringstate
+    updateIceGatheringState() {
+        const all = this.iceTransports;
+        function allMatch(...state) {
+            return (all.filter((check) => state.includes(check.iceGather.gatheringState))
+                .length === all.length);
+        }
+        let newState;
+        if (all.length && allMatch("complete")) {
+            newState = "complete";
+        }
+        else if (!all.length || allMatch("new", "complete")) {
+            newState = "new";
+        }
+        else if (all.map((check) => check.iceGather.gatheringState).includes("gathering")) {
+            newState = "gathering";
+        }
+        else {
+            newState = "new";
+        }
+        if (this.iceGatheringState === newState) {
+            return;
+        }
+        log("iceGatheringStateChange", newState);
+        this.iceGatheringState = newState;
+        this.iceGatheringStateChange.execute(newState);
+        this.emit("icegatheringstatechange", newState);
     }
-    updateIceConnectionState(state) {
-        log("iceConnectionStateChange", state);
-        this.iceConnectionState = state;
-        this.iceConnectionStateChange.execute(state);
-        this.emit("iceconnectionstatechange", state);
+    // https://w3c.github.io/webrtc-pc/#dom-rtciceconnectionstate
+    updateIceConnectionState() {
+        const all = this.iceTransports;
+        let newState;
+        function allMatch(...state) {
+            return (all.filter((check) => state.includes(check.state)).length === all.length);
+        }
+        if (this.connectionState === "closed") {
+            newState = "closed";
+        }
+        else if (allMatch("failed")) {
+            newState = "failed";
+        }
+        else if (allMatch("disconnected")) {
+            newState = "disconnected";
+        }
+        else if (allMatch("new", "closed")) {
+            newState = "new";
+        }
+        else if (allMatch("new", "checking")) {
+            newState = "checking";
+        }
+        else if (allMatch("completed", "closed")) {
+            newState = "completed";
+        }
+        else if (allMatch("connected", "completed", "closed")) {
+            newState = "connected";
+        }
+        else {
+            // unreachable?
+            newState = "new";
+        }
+        if (this.iceConnectionState === newState) {
+            return;
+        }
+        log("iceConnectionStateChange", newState);
+        this.iceConnectionState = newState;
+        this.iceConnectionStateChange.execute(newState);
+        this.emit("iceconnectionstatechange", newState);
     }
     setSignalingState(state) {
         log("signalingStateChange", state);
@@ -958,5 +1102,6 @@ exports.defaultPeerConfig = {
     iceServers: [{ urls: "stun:stun.l.google.com:19302" }],
     icePortRange: undefined,
     dtls: {},
+    bundlePolicy: "max-compat",
 };
 //# sourceMappingURL=peerConnection.js.map