werift 0.20.0 → 0.21.0

package/src/media/track.ts

@@ -1,7 +1,12 @@
-import Event from "rx.mini";
 import { v4 } from "uuid";
-
-import { type RtcpPacket, type RtpHeader, RtpPacket } from "../../../rtp/src";
+import { Event } from "../imports/common";
+
+import {
+  type Extensions,
+  type RtcpPacket,
+  type RtpHeader,
+  RtpPacket,
+} from "../../../rtp/src";
 import { EventTarget } from "../helper";
 import type { Kind } from "../types/domain";
 import type { RTCRtpCodecParameters } from "./parameters";
@@ -22,7 +27,7 @@ export class MediaStreamTrack extends EventTarget {
   /**todo impl */
   enabled = true;
 
-  readonly onReceiveRtp = new Event<[RtpPacket]>();
+  readonly onReceiveRtp = new Event<[RtpPacket, Extensions?]>();
   readonly onReceiveRtcp = new Event<[RtcpPacket]>();
   readonly onSourceChanged = new Event<
     [Pick<RtpHeader, "sequenceNumber" | "timestamp">]

package/src/nonstandard/recorder/index.ts

@@ -1,8 +1,10 @@
-import Event from "rx.mini";
+import { Event } from "../../imports/common";
 import type { MediaStreamTrack } from "../../media/track";
 import type { MediaWriter, StreamEvent } from "./writer";
 import { WebmFactory } from "./writer/webm";
 
+export type { StreamEvent };
+
 export class MediaRecorder {
   writer: MediaWriter;
   ext?: string;
@@ -90,6 +92,7 @@ export class MediaRecorder {
 export interface MediaRecorderOptions {
   width: number;
   height: number;
+  roll: number;
   jitterBufferLatency: number;
   jitterBufferSize: number;
   disableLipSync: boolean;

package/src/nonstandard/recorder/writer/index.ts

@@ -1,7 +1,7 @@
-import type { Event } from "rx.mini";
 import type { MediaRecorderOptions } from "..";
 import type { MediaStreamTrack } from "../../..";
 import type { WebmOutput } from "../../../../../rtp/src/extra";
+import type { Event } from "../../../imports/common";
 
 export abstract class MediaWriter {
   constructor(

package/src/nonstandard/recorder/writer/webm.ts

@@ -1,5 +1,5 @@
 import { unlink } from "fs/promises";
-import { EventDisposer } from "rx.mini";
+import { EventDisposer } from "../../../imports/common";
 
 import { MediaWriter } from ".";
 import { type MediaStreamTrack, WeriftError } from "../../..";
@@ -13,6 +13,7 @@ import {
   RtpTimeCallback,
   type SupportedCodec,
   WebmCallback,
+  type WebmTrack,
   saveToFileSystem,
 } from "../../../../../rtp/src/extra";
 
@@ -28,49 +29,52 @@ export class WebmFactory extends MediaWriter {
       await unlink(this.props.path).catch((e) => e);
     }
 
-    const inputTracks = tracks.map((track, i) => {
-      const trackNumber = i + 1;
-      const payloadType = track.codec!.payloadType;
-
-      if (track.kind === "video") {
-        const codec = ((): SupportedCodec => {
-          switch (track.codec?.name.toLowerCase() as SupportedVideoCodec) {
-            case "vp8":
-              return "VP8";
-            case "vp9":
-              return "VP9";
-            case "h264":
-              return "MPEG4/ISO/AVC";
-            case "av1x":
-              return "AV1";
-            default:
-              throw new WeriftError({
-                message: "unsupported codec",
-                payload: { track, path: sourcePath },
-              });
-          }
-        })();
-        return {
-          kind: "video" as const,
-          codec,
-          clockRate: 90000,
-          trackNumber,
-          width: this.props.width ?? 640,
-          height: this.props.height ?? 360,
-          payloadType,
-          track,
-        };
-      } else {
-        return {
-          kind: "audio" as const,
-          codec: "OPUS" as const,
-          clockRate: 48000,
-          trackNumber,
-          payloadType,
-          track,
-        };
-      }
-    });
+    const inputTracks: (WebmTrack & { track: MediaStreamTrack })[] = tracks.map(
+      (track, i) => {
+        const trackNumber = i + 1;
+        const payloadType = track.codec!.payloadType;
+
+        if (track.kind === "video") {
+          const codec = ((): SupportedCodec => {
+            switch (track.codec?.name.toLowerCase() as SupportedVideoCodec) {
+              case "vp8":
+                return "VP8";
+              case "vp9":
+                return "VP9";
+              case "h264":
+                return "MPEG4/ISO/AVC";
+              case "av1x":
+                return "AV1";
+              default:
+                throw new WeriftError({
+                  message: "unsupported codec",
+                  payload: { track, path: sourcePath },
+                });
+            }
+          })();
+          return {
+            kind: "video" as const,
+            codec,
+            clockRate: 90000,
+            trackNumber,
+            width: this.props.width ?? 640,
+            height: this.props.height ?? 360,
+            roll: this.props.roll,
+            payloadType,
+            track,
+          };
+        } else {
+          return {
+            kind: "audio" as const,
+            codec: "OPUS" as const,
+            clockRate: 48000,
+            trackNumber,
+            payloadType,
+            track,
+          };
+        }
+      },
+    );
 
     const webm = new WebmCallback(inputTracks, {
       duration: this.props.defaultDuration ?? 1000 * 60 * 60 * 24,

package/src/peerConnection.ts

@@ -1,8 +1,8 @@
 import debug from "debug";
 import cloneDeep from "lodash/cloneDeep";
 import isEqual from "lodash/isEqual";
-import Event from "rx.mini";
 import * as uuid from "uuid";
+import { Event } from "./imports/common";
 
 import {
   type Address,
@@ -81,7 +81,6 @@ const log = debug("werift:packages/webrtc/src/peerConnection.ts");
 export class RTCPeerConnection extends EventTarget {
   readonly cname = uuid.v4();
   sctpTransport?: RTCSctpTransport;
-  transportEstablished = false;
   config: Required<PeerConfig> = cloneDeep<PeerConfig>(defaultPeerConfig);
   connectionState: ConnectionState = "new";
   iceConnectionState: RTCIceConnectionState = "new";
@@ -95,8 +94,7 @@ export class RTCPeerConnection extends EventTarget {
   private replaceTransceiver(t: RTCRtpTransceiver, index: number) {
     this.transceivers[index] = t;
   }
-
-  candidatesSent = new Set<string>();
+  needRestart = false;
 
   readonly iceGatheringStateChange = new Event<[IceGathererState]>();
   readonly iceConnectionStateChange = new Event<[RTCIceConnectionState]>();
@@ -117,7 +115,7 @@ export class RTCPeerConnection extends EventTarget {
   onconnectionstatechange?: Callback;
 
   private readonly router = new RtpRouter();
-  private readonly certificates: RTCCertificate[] = [];
+  private certificate?: RTCCertificate;
   sctpRemotePort?: number;
   private seenMid = new Set<string>();
   private currentLocalDescription?: SessionDescription;
@@ -147,9 +145,28 @@ export class RTCPeerConnection extends EventTarget {
     return this.router.extIdUriMap;
   }
 
+  get iceGeneration() {
+    return this.iceTransports[0].connection.generation;
+  }
+
   constructor(config: Partial<PeerConfig> = {}) {
     super();
 
+    this.setConfiguration(config);
+
+    this.iceConnectionStateChange.subscribe((state) => {
+      switch (state) {
+        case "disconnected":
+          this.setConnectionState("disconnected");
+          break;
+        case "closed":
+          this.close();
+          break;
+      }
+    });
+  }
+
+  setConfiguration(config: Partial<PeerConfig>) {
     deepMerge(this.config, config);
 
     if (this.config.icePortRange) {
@@ -194,23 +211,15 @@ export class RTCPeerConnection extends EventTarget {
 
     if (this.config.dtls) {
       const { keys } = this.config.dtls;
+
       if (keys) {
-        this.certificates.push(
-          new RTCCertificate(keys.keyPem, keys.certPem, keys.signatureHash),
+        this.certificate = new RTCCertificate(
+          keys.keyPem,
+          keys.certPem,
+          keys.signatureHash,
         );
       }
     }
-
-    this.iceConnectionStateChange.subscribe((state) => {
-      switch (state) {
-        case "disconnected":
-          this.setConnectionState("disconnected");
-          break;
-        case "closed":
-          this.close();
-          break;
-      }
-    });
   }
 
   get localDescription() {
@@ -251,8 +260,16 @@ export class RTCPeerConnection extends EventTarget {
     return this.config;
   }
 
-  async createOffer() {
+  async createOffer({ iceRestart }: { iceRestart?: boolean } = {}) {
+    if (iceRestart || this.needRestart) {
+      this.needRestart = false;
+      for (const t of this.iceTransports) {
+        t.restart();
+      }
+    }
+
     await this.ensureCerts();
+
     const description = this.buildOfferSdp();
     return description.toJSON();
   }
@@ -465,7 +482,9 @@ export class RTCPeerConnection extends EventTarget {
 
   private needNegotiation = async () => {
     this.shouldNegotiationneeded = true;
-    if (this.negotiationneeded || this.signalingState !== "stable") return;
+    if (this.negotiationneeded || this.signalingState !== "stable") {
+      return;
+    }
     this.shouldNegotiationneeded = false;
     setImmediate(() => {
       this.negotiationneeded = true;
@@ -493,11 +512,13 @@ export class RTCPeerConnection extends EventTarget {
       additionalHostAddresses: this.config.iceAdditionalHostAddresses,
       filterStunResponse: this.config.iceFilterStunResponse,
       filterCandidatePair: this.config.iceFilterCandidatePair,
+      localPasswordPrefix: this.config.icePasswordPrefix,
       useIpv4: this.config.iceUseIpv4,
       useIpv6: this.config.iceUseIpv6,
+      turnTransport: this.config.forceTurnTCP === true ? "tcp" : "udp",
     });
     if (existing) {
-      iceGatherer.connection.localUserName = existing.connection.localUserName;
+      iceGatherer.connection.localUsername = existing.connection.localUsername;
       iceGatherer.connection.localPassword = existing.connection.localPassword;
     }
     iceGatherer.onGatheringStateChange.subscribe(() => {
@@ -508,8 +529,10 @@ export class RTCPeerConnection extends EventTarget {
     iceTransport.onStateChange.subscribe(() => {
       this.updateIceConnectionState();
     });
-
-    iceTransport.iceGather.onIceCandidate = (candidate) => {
+    iceTransport.onNegotiationNeeded.subscribe(() => {
+      this.needNegotiation();
+    });
+    iceTransport.onIceCandidate.subscribe((candidate) => {
       if (!this.localDescription) {
         log("localDescription not found when ice candidate was gathered");
         return;
@@ -548,28 +571,18 @@ export class RTCPeerConnection extends EventTarget {
 
       candidate.foundation = "candidate:" + candidate.foundation;
 
-      // prevent ice candidates that have already been sent from being being resent
-      // when the connection is renegotiated during a later setLocalDescription call.
-      if (candidate.sdpMid) {
-        const candidateKey = `${candidate.foundation}:${candidate.sdpMid}`;
-        if (this.candidatesSent.has(candidateKey)) {
-          return;
-        }
-        this.candidatesSent.add(candidateKey);
-      }
-
       this.onIceCandidate.execute(candidate.toJSON());
       if (this.onicecandidate) {
         this.onicecandidate({ candidate: candidate.toJSON() });
       }
       this.emit("icecandidate", { candidate });
-    };
+    });
 
     const dtlsTransport = new RTCDtlsTransport(
       this.config,
       iceTransport,
       this.router,
-      this.certificates,
+      this.certificate,
       srtpProfiles,
     );
 
@@ -616,7 +629,7 @@ export class RTCPeerConnection extends EventTarget {
     }
 
     // # assign MID
-    description.media.forEach((media, i) => {
+    for (const [i, media] of enumerate(description.media)) {
       const mid = media.rtp.muxId!;
       this.seenMid.add(mid);
       if (["audio", "video"].includes(media.kind)) {
@@ -628,9 +641,10 @@ export class RTCPeerConnection extends EventTarget {
       if (media.kind === "application" && this.sctpTransport) {
         this.sctpTransport.mid = mid;
       }
-    });
+    }
 
-    const setupRole = (dtlsTransport: RTCDtlsTransport) => {
+    // setup ice,dtls role
+    for (const dtlsTransport of this.dtlsTransports) {
       const iceTransport = dtlsTransport.iceTransport;
 
       // # set ICE role
@@ -653,34 +667,22 @@ export class RTCPeerConnection extends EventTarget {
           dtlsTransport.role = role;
         }
       }
-    };
-    this.dtlsTransports.forEach((d) => setupRole(d));
+    }
 
     // # configure direction
     if (["answer", "pranswer"].includes(description.type)) {
-      this.transceivers.forEach((t) => {
+      for (const t of this.transceivers) {
         const direction = andDirection(t.direction, t.offerDirection);
         t.setCurrentDirection(direction);
-      });
+      }
     }
 
     // for trickle ice
     this.setLocal(description);
 
-    // # gather candidates
-    const connected = this.iceTransports.find(
-      (transport) => transport.state === "connected",
-    );
-    if (this.remoteIsBundled && connected) {
-      // no need to gather ice candidates on an existing bundled connection
-      await connected.iceGather.gather();
-    } else {
-      await Promise.allSettled(
-        this.iceTransports.map((iceTransport) =>
-          iceTransport.iceGather.gather(),
-        ),
-      );
-    }
+    await this.gatherCandidates().catch((e) => {
+      log("gatherCandidates failed", e);
+    });
 
     // connect transports
     if (description.type === "answer") {
@@ -699,6 +701,20 @@ export class RTCPeerConnection extends EventTarget {
     return description;
   }
 
+  private async gatherCandidates() {
+    // # gather candidates
+    const connected = this.iceTransports.find(
+      (transport) => transport.state === "connected",
+    );
+    if (this.remoteIsBundled && connected) {
+      // no need to gather ice candidates on an existing bundled connection
+    } else {
+      await Promise.allSettled(
+        this.iceTransports.map((iceTransport) => iceTransport.gather()),
+      );
+    }
+  }
+
   private setLocal(description: SessionDescription) {
     description.media
       .filter((m) => ["audio", "video"].includes(m.kind))
@@ -770,20 +786,25 @@ export class RTCPeerConnection extends EventTarget {
   }
 
   private async connect() {
-    if (this.transportEstablished) {
-      return;
-    }
     log("start connect");
 
-    this.setConnectionState("connecting");
-
     await Promise.allSettled(
       this.dtlsTransports.map(async (dtlsTransport) => {
         const { iceTransport } = dtlsTransport;
+        if (iceTransport.state === "connected") {
+          return;
+        }
+
+        this.setConnectionState("connecting");
+
         await iceTransport.start().catch((err) => {
           log("iceTransport.start failed", err);
           throw err;
         });
+
+        if (dtlsTransport.state === "connected") {
+          return;
+        }
         await dtlsTransport.start().catch((err) => {
           log("dtlsTransport.start failed", err);
           throw err;
@@ -800,7 +821,6 @@ export class RTCPeerConnection extends EventTarget {
       }),
     );
 
-    this.transportEstablished = true;
     this.setConnectionState("connected");
   }
 
@@ -850,7 +870,7 @@ export class RTCPeerConnection extends EventTarget {
     return receiveParameters;
   }
 
-  get remoteIsBundled() {
+  private get remoteIsBundled() {
     const remoteSdp = this._remoteDescription;
     if (!remoteSdp) {
       return undefined;
@@ -861,6 +881,11 @@ export class RTCPeerConnection extends EventTarget {
     return bundle;
   }
 
+  restartIce() {
+    this.needRestart = true;
+    this.needNegotiation();
+  }
+
   async setRemoteDescription(sessionDescription: RTCSessionDescriptionInit) {
     if (
       !sessionDescription.sdp ||
@@ -953,9 +978,11 @@ export class RTCPeerConnection extends EventTarget {
 
       const iceTransport = dtlsTransport.iceTransport;
 
-      if (remoteMedia.iceParams && remoteMedia.dtlsParams) {
-        iceTransport.setRemoteParams(remoteMedia.iceParams);
-        dtlsTransport.setRemoteParams(remoteMedia.dtlsParams);
+      if (remoteMedia.iceParams) {
+        const renomination = !!remoteSdp.media.find(
+          (m) => m.direction === "inactive",
+        );
+        iceTransport.setRemoteParams(remoteMedia.iceParams, renomination);
 
         // 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
@@ -963,6 +990,9 @@ export class RTCPeerConnection extends EventTarget {
           iceTransport.connection.iceControlling = true;
         }
       }
+      if (remoteMedia.dtlsParams) {
+        dtlsTransport.setRemoteParams(remoteMedia.dtlsParams);
+      }
 
       // # add ICE candidates
       remoteMedia.iceCandidates.forEach(iceTransport.addRemoteCandidate);
@@ -1034,13 +1064,17 @@ export class RTCPeerConnection extends EventTarget {
       const localCodecs = this.config.codecs[remoteMedia.kind] || [];
 
       const existCodec = findCodecByMimeType(localCodecs, remoteCodec);
-      if (!existCodec) return false;
+      if (!existCodec) {
+        return false;
+      }
 
       if (existCodec?.name.toLowerCase() === "rtx") {
         const params = codecParametersFromString(existCodec.parameters ?? "");
         const pt = params["apt"];
         const origin = remoteMedia.rtp.codecs.find((c) => c.payloadType === pt);
-        if (!origin) return false;
+        if (!origin) {
+          return false;
+        }
         return !!findCodecByMimeType(localCodecs, origin);
       }
 
@@ -1314,22 +1348,18 @@ export class RTCPeerConnection extends EventTarget {
   }
 
   private async ensureCerts() {
-    const ensureCert = async (dtlsTransport: RTCDtlsTransport) => {
-      if (this.certificates.length === 0) {
-        const localCertificate = await dtlsTransport.setupCertificate();
-        this.certificates.push(localCertificate);
-      } else {
-        dtlsTransport.localCertificate = this.certificates[0];
-      }
-    };
+    if (!this.certificate) {
+      this.certificate = await RTCDtlsTransport.SetupCertificate();
+    }
 
     for (const dtlsTransport of this.dtlsTransports) {
-      await ensureCert(dtlsTransport);
+      dtlsTransport.localCertificate = this.certificate;
     }
   }
 
   async createAnswer() {
     await this.ensureCerts();
+
     const description = this.buildAnswer();
     return description.toJSON();
   }
@@ -1392,11 +1422,11 @@ export class RTCPeerConnection extends EventTarget {
 
     if (this.config.bundlePolicy !== "disable") {
       const bundle = new GroupDescription("BUNDLE", []);
-      description.media.forEach((media) => {
+      for (const media of description.media) {
         if (media.direction !== "inactive") {
           bundle.items.push(media.rtp.muxId!);
         }
-      });
+      }
       description.group.push(bundle);
     }
 
@@ -1439,8 +1469,8 @@ export class RTCPeerConnection extends EventTarget {
 
     function allMatch(...state: IceGathererState[]) {
       return (
-        all.filter((check) => state.includes(check.iceGather.gatheringState))
-          .length === all.length
+        all.filter((check) => state.includes(check.gatheringState)).length ===
+        all.length
       );
     }
 
@@ -1450,9 +1480,7 @@ export class RTCPeerConnection extends EventTarget {
       newState = "complete";
     } else if (!all.length || allMatch("new", "complete")) {
       newState = "new";
-    } else if (
-      all.map((check) => check.iceGather.gatheringState).includes("gathering")
-    ) {
+    } else if (all.map((check) => check.gatheringState).includes("gathering")) {
       newState = "gathering";
     } else {
       newState = "new";
@@ -1519,7 +1547,9 @@ export class RTCPeerConnection extends EventTarget {
     log("connectionStateChange", state);
     this.connectionState = state;
     this.connectionStateChange.execute(state);
-    if (this.onconnectionstatechange) this.onconnectionstatechange();
+    if (this.onconnectionstatechange) {
+      this.onconnectionstatechange();
+    }
     this.emit("connectionstatechange");
   }
 
@@ -1599,11 +1629,10 @@ export function addTransportDescription(
   dtlsTransport: RTCDtlsTransport,
 ) {
   const iceTransport = dtlsTransport.iceTransport;
-  const iceGatherer = iceTransport.iceGather;
 
-  media.iceCandidates = iceGatherer.localCandidates;
-  media.iceCandidatesComplete = iceGatherer.gatheringState === "complete";
-  media.iceParams = iceGatherer.localParameters;
+  media.iceCandidates = iceTransport.localCandidates;
+  media.iceCandidatesComplete = iceTransport.gatheringState === "complete";
+  media.iceParams = iceTransport.localParameters;
   media.iceOptions = "trickle";
 
   media.host = DISCARD_HOST;
@@ -1661,6 +1690,7 @@ export interface PeerConfig {
   iceAdditionalHostAddresses: string[] | undefined;
   iceUseIpv4: boolean;
   iceUseIpv6: boolean;
+  forceTurnTCP: boolean;
   /** If provided, is called on each STUN request.
    * Return `true` if a STUN response should be sent, false if it should be skipped. */
   iceFilterStunResponse:
@@ -1670,6 +1700,7 @@ export interface PeerConfig {
   dtls: Partial<{
     keys: DtlsKeys;
   }>;
+  icePasswordPrefix: string | undefined;
   bundlePolicy: BundlePolicy;
   debug: Partial<{
     /**% */
@@ -1737,10 +1768,12 @@ export const defaultPeerConfig: PeerConfig = {
   iceUseIpv6: true,
   iceFilterStunResponse: undefined,
   iceFilterCandidatePair: undefined,
+  icePasswordPrefix: undefined,
   dtls: {},
   bundlePolicy: "max-compat",
   debug: {},
   midSuffix: false,
+  forceTurnTCP: false,
 };
 
 export interface RTCTrackEvent {

package/src/sdp.ts

@@ -563,15 +563,22 @@ function ipAddressToSdp(addr: string) {
 
 export function candidateToSdp(c: IceCandidate) {
   let sdp = `${c.foundation} ${c.component} ${c.protocol} ${c.priority} ${c.ip} ${c.port} typ ${c.type}`;
-  if (c.relatedAddress) {
+  if (c.relatedAddress != undefined) {
     sdp += ` raddr ${c.relatedAddress}`;
   }
-  if (c.relatedPort) {
+  if (c.relatedPort != undefined) {
     sdp += ` rport ${c.relatedPort}`;
   }
-  if (c.tcpType) {
+  if (c.tcpType != undefined) {
     sdp += ` tcptype ${c.tcpType}`;
   }
+  if (c.generation != undefined) {
+    sdp += ` generation ${c.generation}`;
+  }
+  if (c.ufrag != undefined) {
+    sdp += ` ufrag ${c.ufrag}`;
+  }
+
   return sdp;
 }
 
@@ -644,6 +651,12 @@ export function candidateFromSdp(sdp: string) {
       case "tcptype":
         candidate.tcpType = bits[i + 1];
         break;
+      case "generation":
+        candidate.generation = Number.parseInt(bits[i + 1]);
+        break;
+      case "ufrag":
+        candidate.ufrag = bits[i + 1];
+        break;
     }
   });