@whereby.com/media 1.14.2 → 1.16.0

package/dist/index.cjs

@@ -2722,6 +2722,27 @@ function setCodecPreferenceSDP(sdp, vp9On, redOn) {
         logger$6.error("setCodecPreferenceSDP error:", error);
     }
 }
+function cleanSdp(sdp) {
+    try {
+        const sdpObject = sdpTransform__namespace.parse(sdp);
+        sdpObject.media.forEach(mediaObject => {
+            const usedPayloads = {};
+            if (mediaObject.payloads)
+                mediaObject.payloads = ("" + mediaObject.payloads).split(' ').filter(p => !usedPayloads[p] && (usedPayloads[p] = true)).join(' ');
+            const usedRtps = {};
+            mediaObject.rtp = mediaObject.rtp.filter(p => !p.payload || (usedPayloads[p.payload] && !usedRtps[p.payload] && (usedRtps[p.payload] = true)));
+            const usedFmtps = {};
+            if (mediaObject.fmtp)
+                mediaObject.fmtp = mediaObject.fmtp.filter(p => !p.payload || (usedPayloads[p.payload] && !usedFmtps[p.payload] && (usedFmtps[p.payload] = true)));
+            const usedRtcpFb = {};
+            if (mediaObject.rtcpFb)
+                mediaObject.rtcpFb = mediaObject.rtcpFb.filter(p => !p.payload || (usedPayloads[p.payload] && !usedRtcpFb[p.payload + p.type] && (usedRtcpFb[p.payload + p.type] = true)));
+        });
+        return sdpTransform__namespace.write(sdpObject);
+    }
+    catch (_) { }
+    return sdp;
+}
 function maybeRejectNoH264(sdp) {
     if (browserName$2 !== "safari") {
         return sdp;
@@ -3043,13 +3064,7 @@ class Session {
         });
     }
     handleAnswer(message) {
-        if (this.pendingOffer) {
-            const pendingOffer = this.pendingOffer;
-            delete this.pendingOffer;
-            return this.pc.setLocalDescription(pendingOffer).then(() => this.handleAnswer(message));
-        }
-        let sdp = message.sdp;
-        sdp = filterMsidSemantic(sdp);
+        const sdp = filterMsidSemantic(message.sdp);
         const desc = { type: message.type, sdp };
         return this._setRemoteDescription(desc).then(() => {
             return setVideoBandwidthUsingSetParameters(this.pc, this.bandwidth);
@@ -3503,6 +3518,9 @@ var rtcManagerEvents = {
     SFU_CONNECTION_CLOSED: "sfu_connection_closed",
     COLOCATION_SPEAKER: "colocation_speaker",
     DOMINANT_SPEAKER: "dominant_speaker",
+    PC_SLD_FAILURE: "pc_sld_failure",
+    PC_ON_ANSWER_FAILURE: "pc_on_answer_failure",
+    PC_ON_OFFER_FAILURE: "pc_on_offer_failure",
 };
 
 var _a$2, _b;
@@ -3540,7 +3558,6 @@ class P2pRtcManager {
         this._isAudioOnlyMode = false;
         this.offerOptions = { offerToReceiveAudio: true, offerToReceiveVideo: true };
         this._pendingActionsForConnectedPeerConnections = [];
-        this._nodeJsClients = [];
         this._audioTrackOnEnded = () => {
             rtcStats.sendEvent("audio_ended", { unloading: unloading$1 });
             this._emit(rtcManagerEvents.MICROPHONE_STOPPED_WORKING, {});
@@ -3656,11 +3673,6 @@ class P2pRtcManager {
     setupSocketListeners() {
         this._socketListenerDeregisterFunctions = [
             () => this._clearMediaServersRefresh(),
-            this._serverSocket.on(PROTOCOL_RESPONSES.NEW_CLIENT, (data) => {
-                if (data.client.isDialIn && !this._nodeJsClients.includes(data.client.id)) {
-                    this._nodeJsClients.push(data.client.id);
-                }
-            }),
             this._serverSocket.on(PROTOCOL_RESPONSES.MEDIASERVER_CONFIG, (data) => {
                 if (data.error) {
                     logger$4.warn("FETCH_MEDIASERVER_CONFIG failed:", data.error);
@@ -3688,27 +3700,33 @@ class P2pRtcManager {
                 session.addIceCandidate(null);
             }),
             this._serverSocket.on(RELAY_MESSAGES.SDP_OFFER, (data) => {
+                var _a, _b;
                 const session = this._getSession(data.clientId);
                 if (!session) {
                     logger$4.warn("No RTCPeerConnection on SDP_OFFER", data);
                     return;
                 }
                 const offer = this._transformIncomingSdp(data.message, session.pc);
-                session.handleOffer(offer).then((answer) => {
+                (_b = (_a = session.handleOffer(offer).then((answer) => {
                     this._emitServerEvent(RELAY_MESSAGES.SDP_ANSWER, {
                         receiverId: data.clientId,
                         message: this._transformOutgoingSdp(answer),
                     });
+                })).catch) === null || _b === void 0 ? void 0 : _b.call(_a, (e) => {
+                    this._emit(rtcManagerEvents.PC_ON_OFFER_FAILURE, e);
                 });
             }),
             this._serverSocket.on(RELAY_MESSAGES.SDP_ANSWER, (data) => {
+                var _a, _b;
                 const session = this._getSession(data.clientId);
                 if (!session) {
                     logger$4.warn("No RTCPeerConnection on SDP_ANSWER", data);
                     return;
                 }
                 const answer = this._transformIncomingSdp(data.message, session.pc);
-                session.handleAnswer(answer);
+                (_b = (_a = session.handleAnswer(answer)) === null || _a === void 0 ? void 0 : _a.catch) === null || _b === void 0 ? void 0 : _b.call(_a, (e) => {
+                    this._emit(rtcManagerEvents.PC_ON_ANSWER_FAILURE, e);
+                });
             }),
             this._serverSocket.on(PROTOCOL_RESPONSES.ROOM_JOINED, ({ room: { sfuServer: isSfu } }) => {
                 if (isSfu || !this._wasScreenSharing)
@@ -3858,7 +3876,7 @@ class P2pRtcManager {
     _transformOutgoingSdp(original) {
         return { type: original.type, sdpU: original.sdp };
     }
-    _createSession({ clientId, initialBandwidth, isOfferer, peerConnectionId, shouldAddLocalVideo, enforceTurnProtocol, }) {
+    _createSession({ clientId, initialBandwidth, isOfferer, peerConnectionId, shouldAddLocalVideo, }) {
         if (!peerConnectionId) {
             throw new Error("peerConnectionId is missing");
         }
@@ -3894,13 +3912,13 @@ class P2pRtcManager {
                 return entry;
             });
         }
-        if (enforceTurnProtocol || this._features.useOnlyTURN) {
+        if (this._features.useOnlyTURN) {
             peerConnectionConfig.iceTransportPolicy = "relay";
             const filter = {
                 onlyudp: /^turn:.*transport=udp$/,
                 onlytcp: /^turn:.*transport=tcp$/,
                 onlytls: /^turns:.*transport=tcp$/,
-            }[enforceTurnProtocol || this._features.useOnlyTURN];
+            }[this._features.useOnlyTURN];
             if (filter) {
                 peerConnectionConfig.iceServers = peerConnectionConfig.iceServers.filter((entry) => entry.url && entry.url.match(filter));
             }
@@ -4160,16 +4178,11 @@ class P2pRtcManager {
         else {
             initialBandwidth = this._changeBandwidthForAllClients(true);
         }
-        let enforceTurnProtocol;
-        if (this._nodeJsClients.includes(clientId)) {
-            enforceTurnProtocol = this._features.isNodeSdk ? "onlyudp" : "onlytls";
-        }
         session = this._createP2pSession({
             clientId,
             initialBandwidth,
             shouldAddLocalVideo: true,
             isOfferer: true,
-            enforceTurnProtocol,
         });
         this._negotiatePeerConnection(clientId, session);
         return Promise.resolve(session);
@@ -4250,7 +4263,7 @@ class P2pRtcManager {
             return;
         }
         session.isOperationPending = true;
-        const { vp9On, av1On, redOn, rtpAbsCaptureTimeOn } = this._features;
+        const { vp9On, av1On, redOn, rtpAbsCaptureTimeOn, cleanSdpOn } = this._features;
         if (vp9On || av1On || redOn) {
             this._setCodecPreferences(pc, vp9On, av1On, redOn);
         }
@@ -4261,26 +4274,17 @@ class P2pRtcManager {
             if ((vp9On || redOn) && browserName$1 === "firefox") {
                 offer.sdp = setCodecPreferenceSDP(offer.sdp, vp9On, redOn);
             }
-            this._emitServerEvent(RELAY_MESSAGES.SDP_OFFER, {
-                receiverId: clientId,
-                message: this._transformOutgoingSdp(offer),
-            });
-            if (browserName$1 === "chrome" &&
-                pc.getSenders().filter((sender) => sender.track && sender.track.kind === "video").length >= 2) {
-                session.pendingOffer = offer;
-                return;
-            }
+            if (cleanSdpOn)
+                offer.sdp = cleanSdp(offer.sdp);
             pc.setLocalDescription(offer).catch((e) => {
                 logger$4.warn("RTCPeerConnection.setLocalDescription() failed with local offer", e);
-                if (this._features.reverseOfferOnFailure) {
-                    if (!this._lastReverseDirectionAttemptByClientId)
-                        this._lastReverseDirectionAttemptByClientId = {};
-                    if (!this._lastReverseDirectionAttemptByClientId[clientId] ||
-                        this._lastReverseDirectionAttemptByClientId[clientId] < Date.now() - 10000) {
-                        this.acceptNewStream({ clientId, streamId: clientId, shouldAddLocalVideo: true });
-                        this._lastReverseDirectionAttemptByClientId[clientId] = Date.now();
-                    }
-                }
+                this._emit(rtcManagerEvents.PC_SLD_FAILURE, e);
+                throw e;
+            }).then(() => {
+                this._emitServerEvent(RELAY_MESSAGES.SDP_OFFER, {
+                    receiverId: clientId,
+                    message: this._transformOutgoingSdp(offer),
+                });
             });
         })
             .catch((e) => {
@@ -4341,14 +4345,13 @@ class P2pRtcManager {
         });
         return bandwidth;
     }
-    _createP2pSession({ clientId, initialBandwidth, shouldAddLocalVideo = false, isOfferer = false, enforceTurnProtocol, }) {
+    _createP2pSession({ clientId, initialBandwidth, shouldAddLocalVideo = false, isOfferer = false, }) {
         const session = this._createSession({
             peerConnectionId: clientId,
             clientId,
             initialBandwidth,
             shouldAddLocalVideo,
             isOfferer,
-            enforceTurnProtocol,
         });
         const pc = session.pc;
         if (this._features.increaseIncomingMediaBufferOn) {
@@ -4462,7 +4465,7 @@ class P2pRtcManager {
         };
         return session;
     }
-    acceptNewStream({ streamId, clientId, shouldAddLocalVideo, enforceTurnProtocol, }) {
+    acceptNewStream({ streamId, clientId, shouldAddLocalVideo, }) {
         let session = this._getSession(clientId);
         if (session && streamId !== clientId) {
             return session;
@@ -4479,7 +4482,6 @@ class P2pRtcManager {
             clientId,
             initialBandwidth,
             shouldAddLocalVideo: !!shouldAddLocalVideo,
-            enforceTurnProtocol,
             isOfferer: false,
         });
         this._emitServerEvent(RELAY_MESSAGES.READY_TO_RECEIVE_OFFER, {
@@ -6929,6 +6931,7 @@ exports.captureCommonSsrcMetrics = captureCommonSsrcMetrics;
 exports.captureSsrcInfo = captureSsrcInfo;
 exports.captureVideoSsrcMetrics = captureVideoSsrcMetrics;
 exports.changeMediaDirection = changeMediaDirection;
+exports.cleanSdp = cleanSdp;
 exports.compareLocalDevices = compareLocalDevices;
 exports.createACFCalculator = createACFCalculator;
 exports.createMicAnalyser = createMicAnalyser;