werift 0.15.2 → 0.15.5

package/src/peerConnection.ts

@@ -230,11 +230,19 @@ export class RTCPeerConnection extends EventTarget {
 
   async createOffer() {
     await this.ensureCerts();
+    const description = this.buildOfferSdp();
+    return description.toJSON();
+  }
 
+  buildOfferSdp() {
     this.transceivers.forEach((transceiver) => {
-      transceiver.codecs = this.configuration.codecs[transceiver.kind];
-      transceiver.headerExtensions =
-        this.configuration.headerExtensions[transceiver.kind];
+      if (transceiver.codecs.length === 0) {
+        transceiver.codecs = this.configuration.codecs[transceiver.kind];
+      }
+      if (transceiver.headerExtensions.length === 0) {
+        transceiver.headerExtensions =
+          this.configuration.headerExtensions[transceiver.kind];
+      }
     });
 
     const description = new SessionDescription();
@@ -253,22 +261,24 @@ export class RTCPeerConnection extends EventTarget {
         return;
       }
       if (m.kind === "application") {
+        if (!this.sctpTransport) {
+          throw new Error("sctpTransport not found");
+        }
+        this.sctpTransport.mLineIndex = i;
         description.media.push(
-          createMediaDescriptionForSctp(this.sctpTransport!, mid)
+          createMediaDescriptionForSctp(this.sctpTransport)
         );
       } else {
         const transceiver = this.getTransceiverByMid(mid);
         if (!transceiver) {
-          log("transceiver by mid not found", mid);
-          return;
+          throw new Error("transceiver not found");
         }
         transceiver.mLineIndex = i;
         description.media.push(
           createMediaDescriptionForTransceiver(
             transceiver,
             this.cname,
-            transceiver.direction,
-            mid
+            transceiver.direction
           )
         );
       }
@@ -279,26 +289,27 @@ export class RTCPeerConnection extends EventTarget {
       .filter((t) => !description.media.find((m) => m.rtp.muxId === t.mid))
       .forEach((transceiver) => {
         transceiver.mLineIndex = description.media.length;
+        if (transceiver.mid == undefined) {
+          transceiver.mid = allocateMid(this.seenMid) + "_srtp";
+        }
         description.media.push(
           createMediaDescriptionForTransceiver(
             transceiver,
             this.cname,
-            transceiver.direction,
-            allocateMid(this.seenMid)
+            transceiver.direction
           )
         );
       });
 
     if (
       this.sctpTransport &&
-      !description.media.find((m) => this.sctpTransport!.mid === m.rtp.muxId)
+      !description.media.find((m) => m.kind === "application")
     ) {
-      description.media.push(
-        createMediaDescriptionForSctp(
-          this.sctpTransport,
-          allocateMid(this.seenMid)
-        )
-      );
+      this.sctpTransport.mLineIndex = description.media.length;
+      if (this.sctpTransport.mid == undefined) {
+        this.sctpTransport.mid = allocateMid(this.seenMid) + "_sctp";
+      }
+      description.media.push(createMediaDescriptionForSctp(this.sctpTransport));
     }
 
     if (this.configuration.bundlePolicy !== "disable") {
@@ -309,7 +320,7 @@ export class RTCPeerConnection extends EventTarget {
       description.group.push(bundle);
     }
 
-    return description.toJSON();
+    return description;
   }
 
   createDataChannel(
@@ -423,19 +434,32 @@ export class RTCPeerConnection extends EventTarget {
 
     iceTransport.iceGather.onIceCandidate = (candidate) => {
       if (!this.localDescription) return;
-      const sdp = SessionDescription.parse(this.localDescription.sdp);
-      const media = sdp.media[0];
-      if (!media) {
-        log("media not exist");
-        return;
+
+      if (this.configuration.bundlePolicy === "max-bundle") {
+        candidate.sdpMLineIndex = 0;
+        candidate.sdpMid = this._localDescription?.media[0].rtp.muxId;
+      } else {
+        const transceiver = this.transceivers.find(
+          (t) => t.dtlsTransport.iceTransport.id === iceTransport.id
+        );
+        if (transceiver) {
+          candidate.sdpMLineIndex = transceiver.mLineIndex;
+          candidate.sdpMid = transceiver.mid;
+        }
+        if (
+          this.sctpTransport?.dtlsTransport.iceTransport.id === iceTransport.id
+        ) {
+          candidate.sdpMLineIndex = this.sctpTransport.mLineIndex;
+          candidate.sdpMid = this.sctpTransport.mid;
+        }
       }
-      candidate.sdpMLineIndex = 0;
-      candidate.sdpMid = media.rtp.muxId;
+
       candidate.foundation = "candidate:" + candidate.foundation;
 
       this.onIceCandidate.execute(candidate.toJSON());
-      if (this.onicecandidate)
+      if (this.onicecandidate) {
         this.onicecandidate({ candidate: candidate.toJSON() });
+      }
       this.emit("icecandidate", { candidate });
     };
 
@@ -540,10 +564,20 @@ export class RTCPeerConnection extends EventTarget {
     // for trickle ice
     this.setLocal(description);
 
-    // # gather candidates
-    for (const iceTransport of this.iceTransports) {
-      await iceTransport.iceGather.gather();
+    // connect transports
+    if (description.type === "answer") {
+      log("callee start connect");
+      this.connect().catch((err) => {
+        log("connect failed", err);
+        this.setConnectionState("failed");
+      });
     }
+
+    // # gather candidates
+    await Promise.all(
+      this.iceTransports.map((iceTransport) => iceTransport.iceGather.gather())
+    );
+
     description.media
       .filter((m) => ["audio", "video"].includes(m.kind))
       .forEach((m, i) => {
@@ -556,15 +590,6 @@ export class RTCPeerConnection extends EventTarget {
 
     this.setLocal(description);
 
-    // connect transports
-    if (description.type === "answer") {
-      log("callee start connect");
-      this.connect().catch((err) => {
-        log("connect failed", err);
-        this.setConnectionState("failed");
-      });
-    }
-
     if (this.shouldNegotiationneeded) {
       this.needNegotiation();
     }
@@ -581,10 +606,54 @@ export class RTCPeerConnection extends EventTarget {
     }
   }
 
+  private getTransportByMid(mid: string) {
+    let iceTransport: RTCIceTransport | undefined;
+
+    const transceiver = this.transceivers.find((t) => t.mid === mid);
+    if (transceiver) {
+      iceTransport = transceiver.dtlsTransport.iceTransport;
+    } else if (!iceTransport && this.sctpTransport?.mid === mid) {
+      iceTransport = this.sctpTransport?.dtlsTransport.iceTransport;
+    }
+
+    return iceTransport;
+  }
+
+  private getTransportByMLineIndex(index: number) {
+    const sdp = this.buildOfferSdp();
+    const media = sdp.media[index];
+    if (!media) {
+      return;
+    }
+    const transport = this.getTransportByMid(media.rtp.muxId!);
+
+    return transport;
+  }
+
   async addIceCandidate(candidateMessage: RTCIceCandidate) {
     const candidate = IceCandidate.fromJSON(candidateMessage);
-    for (const iceTransport of this.iceTransports) {
+    if (!candidate) {
+      return;
+    }
+
+    let iceTransport: RTCIceTransport | undefined;
+
+    if (typeof candidate.sdpMid === "number") {
+      iceTransport = this.getTransportByMid(candidate.sdpMid);
+    }
+
+    if (!iceTransport && typeof candidate.sdpMLineIndex === "number") {
+      iceTransport = this.getTransportByMLineIndex(candidate.sdpMLineIndex);
+    }
+
+    if (!iceTransport) {
+      iceTransport = this.iceTransports[0];
+    }
+
+    if (iceTransport) {
       await iceTransport.addRemoteCandidate(candidate);
+    } else {
+      log("iceTransport not found", candidate);
     }
   }
 
@@ -689,84 +758,90 @@ export class RTCPeerConnection extends EventTarget {
     let bundleTransport: RTCDtlsTransport | undefined;
 
     // # apply description
-    await Promise.all(
-      enumerate(remoteSdp.media).map(async ([i, remoteMedia]) => {
-        let dtlsTransport: RTCDtlsTransport | undefined;
-
-        if (["audio", "video"].includes(remoteMedia.kind)) {
-          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",
-            });
-            this.onRemoteTransceiverAdded.execute(transceiver);
-          }
 
-          if (bundle) {
-            if (!bundleTransport) {
-              bundleTransport = transceiver.dtlsTransport;
-            } else {
-              transceiver.setDtlsTransport(bundleTransport);
-            }
-          }
+    const transports = enumerate(remoteSdp.media).map(([i, remoteMedia]) => {
+      let dtlsTransport: RTCDtlsTransport | undefined;
 
-          dtlsTransport = transceiver.dtlsTransport;
+      if (["audio", "video"].includes(remoteMedia.kind)) {
+        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.mid = remoteMedia.rtp.muxId;
+          this.onRemoteTransceiverAdded.execute(transceiver);
+        }
 
-          this.setRemoteRTP(transceiver, remoteMedia, remoteSdp.type, i);
-        } else if (remoteMedia.kind === "application") {
-          if (!this.sctpTransport) {
-            this.sctpTransport = this.createSctpTransport();
+        if (bundle) {
+          if (!bundleTransport) {
+            bundleTransport = transceiver.dtlsTransport;
+          } else {
+            transceiver.setDtlsTransport(bundleTransport);
           }
+        }
 
-          if (bundle) {
-            if (!bundleTransport) {
-              bundleTransport = this.sctpTransport.dtlsTransport;
-            } else {
-              this.sctpTransport.setDtlsTransport(bundleTransport);
-            }
-          }
+        dtlsTransport = transceiver.dtlsTransport;
 
-          dtlsTransport = this.sctpTransport.dtlsTransport;
+        this.setRemoteRTP(transceiver, remoteMedia, remoteSdp.type, i);
+      } else if (remoteMedia.kind === "application") {
+        if (!this.sctpTransport) {
+          this.sctpTransport = this.createSctpTransport();
+          this.sctpTransport.mid = remoteMedia.rtp.muxId;
+        }
 
-          this.setRemoteSCTP(remoteMedia, this.sctpTransport);
-        } else {
-          throw new Error("invalid media kind");
+        if (bundle) {
+          if (!bundleTransport) {
+            bundleTransport = this.sctpTransport.dtlsTransport;
+          } else {
+            this.sctpTransport.setDtlsTransport(bundleTransport);
+          }
         }
 
-        const iceTransport = dtlsTransport.iceTransport;
+        dtlsTransport = this.sctpTransport.dtlsTransport;
 
-        if (remoteMedia.iceParams && remoteMedia.dtlsParams) {
-          iceTransport.setRemoteParams(remoteMedia.iceParams);
-          dtlsTransport.setRemoteParams(remoteMedia.dtlsParams);
+        this.setRemoteSCTP(remoteMedia, this.sctpTransport, i);
+      } else {
+        throw new Error("invalid media kind");
+      }
 
-          // 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) {
-            iceTransport.connection.iceControlling = true;
-          }
+      const iceTransport = dtlsTransport.iceTransport;
+
+      if (remoteMedia.iceParams && 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) {
+          iceTransport.connection.iceControlling = true;
         }
+      }
 
-        // # add ICE candidates
-        remoteMedia.iceCandidates.forEach(iceTransport.addRemoteCandidate);
+      // # add ICE candidates
+      remoteMedia.iceCandidates.forEach(iceTransport.addRemoteCandidate);
 
-        await iceTransport.iceGather.gather();
+      if (remoteMedia.iceCandidatesComplete) {
+        iceTransport.addRemoteCandidate(undefined);
+      }
 
-        if (remoteMedia.iceCandidatesComplete) {
-          await iceTransport.addRemoteCandidate(undefined);
-        }
+      // # set DTLS role
+      if (remoteSdp.type === "answer" && remoteMedia.dtlsParams?.role) {
+        dtlsTransport.role =
+          remoteMedia.dtlsParams.role === "client" ? "server" : "client";
+      }
+      return iceTransport;
+    });
 
-        // # set DTLS role
-        if (remoteSdp.type === "answer" && remoteMedia.dtlsParams?.role) {
-          dtlsTransport.role =
-            remoteMedia.dtlsParams.role === "client" ? "server" : "client";
-        }
-      })
-    );
+    if (remoteSdp.type === "offer") {
+      this.setSignalingState("have-remote-offer");
+    } else if (remoteSdp.type === "answer") {
+      this.setSignalingState("stable");
+    }
 
     // connect transports
     if (remoteSdp.type === "answer") {
@@ -777,11 +852,11 @@ export class RTCPeerConnection extends EventTarget {
       });
     }
 
-    if (remoteSdp.type === "offer") {
-      this.setSignalingState("have-remote-offer");
-    } else if (remoteSdp.type === "answer") {
-      this.setSignalingState("stable");
-    }
+    await Promise.all(
+      transports.map(async (iceTransport) => {
+        await iceTransport.iceGather.gather();
+      })
+    );
 
     this.negotiationneeded = false;
     if (this.shouldNegotiationneeded) {
@@ -878,7 +953,8 @@ export class RTCPeerConnection extends EventTarget {
 
   private setRemoteSCTP(
     remoteMedia: MediaDescription,
-    sctpTransport: RTCSctpTransport
+    sctpTransport: RTCSctpTransport,
+    mLineIndex: number
   ) {
     // # configure sctp
     this.sctpRemotePort = remoteMedia.sctpPort;
@@ -887,6 +963,7 @@ export class RTCPeerConnection extends EventTarget {
     }
 
     sctpTransport.setRemotePort(this.sctpRemotePort);
+    sctpTransport.mLineIndex = mLineIndex;
     if (!sctpTransport.mid) {
       sctpTransport.mid = remoteMedia.rtp.muxId;
     }
@@ -1075,6 +1152,12 @@ export class RTCPeerConnection extends EventTarget {
   }
 
   async createAnswer() {
+    await this.ensureCerts();
+    const description = this.buildAnswer();
+    return description.toJSON();
+  }
+
+  private buildAnswer() {
     this.assertNotClosed();
     if (
       !["have-remote-offer", "have-local-pranswer"].includes(
@@ -1087,8 +1170,6 @@ export class RTCPeerConnection extends EventTarget {
       throw new Error("wrong state");
     }
 
-    await this.ensureCerts();
-
     const description = new SessionDescription();
     addSDPHeader("answer", description);
 
@@ -1101,18 +1182,14 @@ export class RTCPeerConnection extends EventTarget {
         media = createMediaDescriptionForTransceiver(
           transceiver,
           this.cname,
-          andDirection(transceiver.direction, transceiver.offerDirection),
-          transceiver.mid!
+          andDirection(transceiver.direction, transceiver.offerDirection)
         );
         dtlsTransport = transceiver.dtlsTransport;
       } else if (remoteMedia.kind === "application") {
         if (!this.sctpTransport || !this.sctpTransport.mid) {
           throw new Error("sctpTransport not found");
         }
-        media = createMediaDescriptionForSctp(
-          this.sctpTransport,
-          this.sctpTransport.mid
-        );
+        media = createMediaDescriptionForSctp(this.sctpTransport);
 
         dtlsTransport = this.sctpTransport.dtlsTransport;
       } else {
@@ -1145,7 +1222,7 @@ export class RTCPeerConnection extends EventTarget {
       description.group.push(bundle);
     }
 
-    return description.toJSON();
+    return description;
   }
 
   async close() {
@@ -1282,8 +1359,7 @@ export class RTCPeerConnection extends EventTarget {
 export function createMediaDescriptionForTransceiver(
   transceiver: RTCRtpTransceiver,
   cname: string,
-  direction: Direction,
-  mid: string
+  direction: Direction
 ) {
   const media = new MediaDescription(
     transceiver.kind,
@@ -1296,7 +1372,7 @@ export function createMediaDescriptionForTransceiver(
   media.rtp = {
     codecs: transceiver.codecs,
     headerExtensions: transceiver.headerExtensions,
-    muxId: mid,
+    muxId: transceiver.mid,
   };
   media.rtcpHost = "0.0.0.0";
   media.rtcpPort = 9;
@@ -1325,10 +1401,7 @@ export function createMediaDescriptionForTransceiver(
   return media;
 }
 
-export function createMediaDescriptionForSctp(
-  sctp: RTCSctpTransport,
-  mid: string
-) {
+export function createMediaDescriptionForSctp(sctp: RTCSctpTransport) {
   const media = new MediaDescription(
     "application",
     DISCARD_PORT,
@@ -1336,7 +1409,7 @@ export function createMediaDescriptionForSctp(
     ["webrtc-datachannel"]
   );
   media.sctpPort = sctp.port;
-  media.rtp.muxId = mid;
+  media.rtp.muxId = sctp.mid;
   media.sctpCapabilities = RTCSctpTransport.getCapabilities();
 
   addTransportDescription(media, sctp.dtlsTransport);

package/src/sdp.ts

@@ -611,14 +611,6 @@ export function candidateFromSdp(sdp: string) {
 
 export class RTCSessionDescription {
   constructor(public sdp: string, public type: "offer" | "answer") {}
-
-  get object() {
-    return SessionDescription.parse(this.sdp);
-  }
-
-  static isThis(o: any) {
-    if (typeof o?.sdp === "string") return true;
-  }
 }
 
 export function addSDPHeader(

package/src/transport/ice.ts

@@ -1,9 +1,11 @@
 import Event from "rx.mini";
+import { v4 } from "uuid";
 
 import { Candidate, Connection, IceOptions } from "../../../ice/src";
 import { candidateFromSdp, candidateToSdp } from "../sdp";
 
 export class RTCIceTransport {
+  readonly id = v4();
   connection = this.gather.connection;
   state: RTCIceConnectionState = "new";
 
@@ -41,12 +43,12 @@ export class RTCIceTransport {
     }
   }
 
-  addRemoteCandidate = async (candidate?: IceCandidate) => {
+  addRemoteCandidate = (candidate?: IceCandidate) => {
     if (!this.connection.remoteCandidatesEnd) {
       if (!candidate) {
-        await this.connection.addRemoteCandidate(undefined);
+        return this.connection.addRemoteCandidate(undefined);
       } else {
-        await this.connection.addRemoteCandidate(candidateToIce(candidate));
+        return this.connection.addRemoteCandidate(candidateToIce(candidate));
       }
     }
   };
@@ -182,6 +184,14 @@ export class RTCIceCandidate {
   static isThis(o: any) {
     if (typeof o?.candidate === "string") return true;
   }
+
+  toJSON() {
+    return {
+      candidate: this.candidate,
+      sdpMid: this.sdpMid,
+      sdpMLineIndex: this.sdpMLineIndex,
+    };
+  }
 }
 
 export class IceCandidate {

package/src/transport/sctp.ts

@@ -28,9 +28,10 @@ export class RTCSctpTransport {
   sctp!: SCTP;
 
   readonly onDataChannel = new Event<[RTCDataChannel]>();
-  readonly uuid = uuid.v4();
+  readonly id = uuid.v4();
 
   mid?: string;
+  mLineIndex?: number;
   bundled = false;
   dataChannels: { [key: number]: RTCDataChannel } = {};