werift 0.19.3 → 0.19.5

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

@@ -2,7 +2,7 @@ import { unlink } from "fs/promises";
 import { EventDisposer } from "rx.mini";
 
 import { MediaWriter } from ".";
-import { MediaStreamTrack, WeriftError } from "../../..";
+import { type MediaStreamTrack, WeriftError } from "../../..";
 import {
   DepacketizeCallback,
   JitterBufferCallback,
@@ -10,7 +10,8 @@ import {
   NtpTimeCallback,
   RtcpSourceCallback,
   RtpSourceCallback,
-  SupportedCodec,
+  RtpTimeCallback,
+  type SupportedCodec,
   WebmCallback,
   saveToFileSystem,
 } from "../../../../../rtp/src/extra";
@@ -23,7 +24,9 @@ export class WebmFactory extends MediaWriter {
   unSubscribers = new EventDisposer();
 
   async start(tracks: MediaStreamTrack[]) {
-    await unlink(this.path).catch((e) => e);
+    if (this.props.path) {
+      await unlink(this.props.path).catch((e) => e);
+    }
 
     const inputTracks = tracks.map((track, i) => {
       const trackNumber = i + 1;
@@ -52,8 +55,8 @@ export class WebmFactory extends MediaWriter {
           codec,
           clockRate: 90000,
           trackNumber,
-          width: this.options.width,
-          height: this.options.height,
+          width: this.props.width ?? 640,
+          height: this.props.height ?? 360,
           payloadType,
           track,
         };
@@ -70,7 +73,7 @@ export class WebmFactory extends MediaWriter {
     });
 
     const webm = new WebmCallback(inputTracks, {
-      duration: this.options.defaultDuration ?? 1000 * 60 * 60 * 24,
+      duration: this.props.defaultDuration ?? 1000 * 60 * 60 * 24,
     });
     const lipsync = new LipsyncCallback();
 
@@ -87,7 +90,9 @@ export class WebmFactory extends MediaWriter {
           rtcpSource.input(rtcp);
         })
         .disposer(this.unSubscribers);
-      const ntpTime = new NtpTimeCallback(clockRate);
+      const time = this.props.disableNtp
+        ? new RtpTimeCallback(clockRate)
+        : new NtpTimeCallback(clockRate);
 
       if (track.kind === "video") {
         const depacketizer = new DepacketizeCallback(codec, {
@@ -96,26 +101,32 @@ export class WebmFactory extends MediaWriter {
         const jitterBuffer = new JitterBufferCallback(clockRate);
 
         rtpSource.pipe(jitterBuffer.input);
-        rtcpSource.pipe(ntpTime.input);
+        rtcpSource.pipe(time.input);
 
-        jitterBuffer.pipe(ntpTime.input);
-        ntpTime.pipe(depacketizer.input);
+        jitterBuffer.pipe(time.input);
+        time.pipe(depacketizer.input);
         depacketizer.pipe(lipsync.inputVideo);
         lipsync.pipeVideo(webm.inputVideo);
       } else {
         const depacketizer = new DepacketizeCallback(codec);
 
-        rtpSource.pipe(ntpTime.input);
-        rtcpSource.pipe(ntpTime.input);
+        rtpSource.pipe(time.input);
+        rtcpSource.pipe(time.input);
 
-        ntpTime.pipe(depacketizer.input);
+        time.pipe(depacketizer.input);
         depacketizer.pipe(lipsync.inputAudio);
         lipsync.pipeAudio(webm.inputAudio);
       }
 
       return rtpSource;
     });
-    webm.pipe(saveToFileSystem(this.path));
+    if (this.props.path) {
+      webm.pipe(saveToFileSystem(this.props.path));
+    } else if (this.props.stream) {
+      webm.pipe(async (o) => {
+        this.props.stream.write(o);
+      });
+    }
   }
 
   async stop() {

package/src/nonstandard/userMedia.ts

@@ -1,4 +1,4 @@
-import { ChildProcess, exec } from "child_process";
+import { type ChildProcess, exec } from "child_process";
 import { createSocket } from "dgram";
 import { setImmediate } from "timers/promises";
 import { v4 } from "uuid";

package/src/peerConnection.ts

@@ -5,24 +5,24 @@ import Event from "rx.mini";
 import * as uuid from "uuid";
 
 import {
-  Address,
-  CandidatePair,
-  InterfaceAddresses,
+  type Address,
+  type CandidatePair,
+  type InterfaceAddresses,
   Recvonly,
   Sendonly,
   Sendrecv,
   deepMerge,
 } from ".";
 import {
-  DtlsKeys,
+  type DtlsKeys,
   codecParametersFromString,
   useNACK,
   usePLI,
   useREMB,
 } from ".";
-import { Profile } from "../../dtls/src/context/srtp";
-import { Message } from "../../ice/src/stun/message";
-import { Protocol } from "../../ice/src/types/model";
+import type { Profile } from "../../dtls/src/context/srtp";
+import type { Message } from "../../ice/src/stun/message";
+import type { Protocol } from "../../ice/src/types/model";
 import {
   DISCARD_HOST,
   DISCARD_PORT,
@@ -35,9 +35,9 @@ import { EventTarget, enumerate } from "./helper";
 import {
   RTCRtpCodecParameters,
   RTCRtpCodingParameters,
-  RTCRtpHeaderExtensionParameters,
-  RTCRtpParameters,
-  RTCRtpReceiveParameters,
+  type RTCRtpHeaderExtensionParameters,
+  type RTCRtpParameters,
+  type RTCRtpReceiveParameters,
   RTCRtpRtxParameters,
   RTCRtpSimulcastParameters,
 } from "./media/parameters";
@@ -45,11 +45,11 @@ import { RtpRouter } from "./media/router";
 import { RTCRtpReceiver } from "./media/rtpReceiver";
 import { RTCRtpSender } from "./media/rtpSender";
 import {
-  Direction,
+  type Direction,
   RTCRtpTransceiver,
-  TransceiverOptions,
+  type TransceiverOptions,
 } from "./media/rtpTransceiver";
-import { MediaStream, MediaStreamTrack } from "./media/track";
+import { MediaStream, type MediaStreamTrack } from "./media/track";
 import {
   GroupDescription,
   MediaDescription,
@@ -60,15 +60,15 @@ import {
 import { RTCCertificate, RTCDtlsTransport } from "./transport/dtls";
 import {
   IceCandidate,
-  IceGathererState,
-  RTCIceCandidate,
-  RTCIceConnectionState,
+  type IceGathererState,
+  type RTCIceCandidate,
+  type RTCIceConnectionState,
   RTCIceGatherer,
   RTCIceTransport,
 } from "./transport/ice";
 import { RTCSctpTransport } from "./transport/sctp";
-import { ConnectionState, Kind, RTCSignalingState } from "./types/domain";
-import { Callback, CallbackWithValue } from "./types/util";
+import type { ConnectionState, Kind, RTCSignalingState } from "./types/domain";
+import type { Callback, CallbackWithValue } from "./types/util";
 import {
   andDirection,
   parseIceServers,
@@ -168,18 +168,20 @@ export class RTCPeerConnection extends EventTarget {
 
       codecParams.payloadType = 96 + i;
       switch (codecParams.name.toLowerCase()) {
-        case "rtx": {
-          codecParams.parameters = `apt=${codecParams.payloadType - 1}`;
-        }
-        break;
-        case "red": {
-          if (codecParams.contentType === "audio") {
-            const redundant = codecParams.payloadType + 1;
-            codecParams.parameters = `${redundant}/${redundant}`;
-            codecParams.payloadType = 63;
+        case "rtx":
+          {
+            codecParams.parameters = `apt=${codecParams.payloadType - 1}`;
           }
-        }
-        break;
+          break;
+        case "red":
+          {
+            if (codecParams.contentType === "audio") {
+              const redundant = codecParams.payloadType + 1;
+              codecParams.parameters = `${redundant}/${redundant}`;
+              codecParams.payloadType = 63;
+            }
+          }
+          break;
       }
     }
 
@@ -506,8 +508,10 @@ export class RTCPeerConnection extends EventTarget {
     });
 
     iceTransport.iceGather.onIceCandidate = (candidate) => {
-      if (!this.localDescription) return;
-
+      if (!this.localDescription) {
+        log("localDescription not found when ice candidate was gathered");
+        return;
+      }
       if (this.config.bundlePolicy === "max-bundle" || this.remoteIsBundled) {
         candidate.sdpMLineIndex = 0;
         const media = this._localDescription?.media[0];
@@ -651,14 +655,6 @@ export class RTCPeerConnection extends EventTarget {
     // for trickle ice
     this.setLocal(description);
 
-    // connect transports
-    if (description.type === "answer") {
-      this.connect().catch((err) => {
-        log("connect failed", err);
-        this.setConnectionState("failed");
-      });
-    }
-
     // # gather candidates
     const connected = this.iceTransports.find(
       (transport) => transport.state === "connected",
@@ -674,6 +670,14 @@ export class RTCPeerConnection extends EventTarget {
       );
     }
 
+    // connect transports
+    if (description.type === "answer") {
+      this.connect().catch((err) => {
+        log("connect failed", err);
+        this.setConnectionState("failed");
+      });
+    }
+
     description.media
       .filter((m) => ["audio", "video"].includes(m.kind))
       .forEach((m, i) => {
@@ -996,18 +1000,6 @@ export class RTCPeerConnection extends EventTarget {
       });
     }
 
-    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(
-        transports.map((iceTransport) => iceTransport.iceGather.gather()),
-      );
-    }
-
     this.negotiationneeded = false;
     if (this.shouldNegotiationneeded) {
       this.needNegotiation();

package/src/sdp.ts

@@ -14,18 +14,18 @@ import {
   RTCRtcpFeedback,
   RTCRtpCodecParameters,
   RTCRtpHeaderExtensionParameters,
-  RTCRtpParameters,
+  type RTCRtpParameters,
   RTCRtpSimulcastParameters,
 } from "./media/parameters";
-import { Direction } from "./media/rtpTransceiver";
+import type { Direction } from "./media/rtpTransceiver";
 import {
-  DtlsRole,
+  type DtlsRole,
   RTCDtlsFingerprint,
   RTCDtlsParameters,
 } from "./transport/dtls";
 import { IceCandidate, RTCIceParameters } from "./transport/ice";
 import { RTCSctpCapabilities } from "./transport/sctp";
-import { Kind } from "./types/domain";
+import type { Kind } from "./types/domain";
 
 export class SessionDescription {
   version = 0;
@@ -51,7 +51,7 @@ export class SessionDescription {
     const session = new SessionDescription();
     sessionLines.forEach((line) => {
       if (line.startsWith("v=")) {
-        session.version = parseInt(line.slice(2), 10);
+        session.version = Number.parseInt(line.slice(2), 10);
       } else if (line.startsWith("o=")) {
         session.origin = line.slice(2);
       } else if (line.startsWith("s=")) {
@@ -63,13 +63,14 @@ export class SessionDescription {
       } else if (line.startsWith("a=")) {
         const [attr, value] = parseAttr(line);
         switch (attr) {
-          case "fingerprint": {
-            const [algorithm, fingerprint] = value?.split(" ") || [];
-            session.dtlsFingerprints.push(
-              new RTCDtlsFingerprint(algorithm, fingerprint),
-            );
-          }
-          break;
+          case "fingerprint":
+            {
+              const [algorithm, fingerprint] = value?.split(" ") || [];
+              session.dtlsFingerprints.push(
+                new RTCDtlsFingerprint(algorithm, fingerprint),
+              );
+            }
+            break;
           case "ice-lite":
             session.iceLite = true;
             break;
@@ -116,7 +117,7 @@ export class SessionDescription {
 
       const currentMedia = new MediaDescription(
         kind,
-        parseInt(m[2]),
+        Number.parseInt(m[2]),
         m[3],
         fmtInt || fmt,
       );
@@ -148,28 +149,30 @@ export class SessionDescription {
             case "end-of-candidates":
               currentMedia.iceCandidatesComplete = true;
               break;
-            case "extmap": {
-              // eslint-disable-next-line prefer-const
-              let [extId, extUri] = value.split(" ");
-              if (extId.includes("/")) {
-                [extId] = extId.split("/");
+            case "extmap":
+              {
+                // eslint-disable-next-line prefer-const
+                let [extId, extUri] = value.split(" ");
+                if (extId.includes("/")) {
+                  [extId] = extId.split("/");
+                }
+                currentMedia.rtp.headerExtensions.push(
+                  new RTCRtpHeaderExtensionParameters({
+                    id: Number.parseInt(extId),
+                    uri: extUri,
+                  }),
+                );
               }
-              currentMedia.rtp.headerExtensions.push(
-                new RTCRtpHeaderExtensionParameters({
-                  id: parseInt(extId),
-                  uri: extUri,
-                }),
-              );
-            }
-            break;
-            case "fingerprint": {
-              if (!value) throw new Error();
-              const [algorithm, fingerprint] = value.split(" ");
-              currentMedia.dtlsParams?.fingerprints.push(
-                new RTCDtlsFingerprint(algorithm, fingerprint),
-              );
-            }
-            break;
+              break;
+            case "fingerprint":
+              {
+                if (!value) throw new Error();
+                const [algorithm, fingerprint] = value.split(" ");
+                currentMedia.dtlsParams?.fingerprints.push(
+                  new RTCDtlsFingerprint(algorithm, fingerprint),
+                );
+              }
+              break;
             case "ice-options":
               currentMedia.iceOptions = value;
               break;
@@ -184,7 +187,7 @@ export class SessionDescription {
               break;
             case "max-message-size":
               currentMedia.sctpCapabilities = new RTCSctpCapabilities(
-                parseInt(value, 10),
+                Number.parseInt(value, 10),
               );
               break;
             case "mid":
@@ -193,12 +196,13 @@ export class SessionDescription {
             case "msid":
               currentMedia.msid = value;
               break;
-            case "rtcp": {
-              const [port, rest] = divide(value, " ");
-              currentMedia.rtcpPort = parseInt(port);
-              currentMedia.rtcpHost = ipAddressFromSdp(rest);
-            }
-            break;
+            case "rtcp":
+              {
+                const [port, rest] = divide(value, " ");
+                currentMedia.rtcpPort = Number.parseInt(port);
+                currentMedia.rtcpHost = ipAddressFromSdp(rest);
+              }
+              break;
             case "rtcp-mux":
               currentMedia.rtcpMux = true;
               break;
@@ -211,61 +215,65 @@ export class SessionDescription {
             case "inactive":
               currentMedia.direction = attr;
               break;
-            case "rtpmap": {
-              const [formatId, formatDesc] = divide(value, " ");
-              const [type, clock, channel] = formatDesc.split("/");
-              let channels: number | undefined;
-              if (currentMedia.kind === "audio") {
-                channels = channel ? parseInt(channel) : 1;
+            case "rtpmap":
+              {
+                const [formatId, formatDesc] = divide(value, " ");
+                const [type, clock, channel] = formatDesc.split("/");
+                let channels: number | undefined;
+                if (currentMedia.kind === "audio") {
+                  channels = channel ? Number.parseInt(channel) : 1;
+                }
+                const codec = new RTCRtpCodecParameters({
+                  mimeType: currentMedia.kind + "/" + type,
+                  channels,
+                  clockRate: Number.parseInt(clock),
+                  payloadType: Number.parseInt(formatId),
+                });
+                currentMedia.rtp.codecs.push(codec);
               }
-              const codec = new RTCRtpCodecParameters({
-                mimeType: currentMedia.kind + "/" + type,
-                channels,
-                clockRate: parseInt(clock),
-                payloadType: parseInt(formatId),
-              });
-              currentMedia.rtp.codecs.push(codec);
-            }
-            break;
-            case "sctpmap": {
-              if (!value) throw new Error();
-              const [formatId, formatDesc] = divide(value, " ");
-              currentMedia.sctpMap[parseInt(formatId)] = formatDesc;
-              currentMedia.sctpPort = parseInt(formatId);
-            }
-            break;
+              break;
+            case "sctpmap":
+              {
+                if (!value) throw new Error();
+                const [formatId, formatDesc] = divide(value, " ");
+                currentMedia.sctpMap[Number.parseInt(formatId)] = formatDesc;
+                currentMedia.sctpPort = Number.parseInt(formatId);
+              }
+              break;
             case "sctp-port":
               if (!value) throw new Error();
-              currentMedia.sctpPort = parseInt(value);
+              currentMedia.sctpPort = Number.parseInt(value);
               break;
-            case "ssrc": {
-              const [ssrcStr, ssrcDesc] = divide(value, " ");
-              const ssrc = parseInt(ssrcStr);
-              const [ssrcAttr, ssrcValue] = divide(ssrcDesc, ":");
-              let ssrcInfo = currentMedia.ssrc.find((v) => v.ssrc === ssrc);
-              if (!ssrcInfo) {
-                ssrcInfo = new SsrcDescription({ ssrc });
-                currentMedia.ssrc.push(ssrcInfo);
-              }
-              if (SSRC_INFO_ATTRS.includes(ssrcAttr)) {
-                ssrcInfo[ssrcAttr] = ssrcValue;
+            case "ssrc":
+              {
+                const [ssrcStr, ssrcDesc] = divide(value, " ");
+                const ssrc = Number.parseInt(ssrcStr);
+                const [ssrcAttr, ssrcValue] = divide(ssrcDesc, ":");
+                let ssrcInfo = currentMedia.ssrc.find((v) => v.ssrc === ssrc);
+                if (!ssrcInfo) {
+                  ssrcInfo = new SsrcDescription({ ssrc });
+                  currentMedia.ssrc.push(ssrcInfo);
+                }
+                if (SSRC_INFO_ATTRS.includes(ssrcAttr)) {
+                  ssrcInfo[ssrcAttr] = ssrcValue;
+                }
               }
-            }
-            break;
+              break;
             case "ssrc-group":
               parseGroup(currentMedia.ssrcGroup, value);
               break;
-            case "rid": {
-              const [rid, direction] = divide(value, " ");
-
-              currentMedia.simulcastParameters.push(
-                new RTCRtpSimulcastParameters({
-                  rid,
-                  direction: direction as any,
-                }),
-              );
-            }
-            break;
+            case "rid":
+              {
+                const [rid, direction] = divide(value, " ");
+
+                currentMedia.simulcastParameters.push(
+                  new RTCRtpSimulcastParameters({
+                    rid,
+                    direction: direction as any,
+                  }),
+                );
+              }
+              break;
           }
         }
       });
@@ -532,7 +540,10 @@ export class MediaDescription {
 }
 
 export class GroupDescription {
-  constructor(public semantic: string, public items: string[]) {}
+  constructor(
+    public semantic: string,
+    public items: string[],
+  ) {}
 
   get str() {
     return `${this.semantic} ${this.items.join(" ")}`;
@@ -613,11 +624,11 @@ export function candidateFromSdp(sdp: string) {
   }
 
   const candidate = new IceCandidate(
-    parseInt(bits[1], 10),
+    Number.parseInt(bits[1], 10),
     bits[0],
     bits[4],
-    parseInt(bits[5], 10),
-    parseInt(bits[3], 10),
+    Number.parseInt(bits[5], 10),
+    Number.parseInt(bits[3], 10),
     bits[2],
     bits[7],
   );
@@ -628,7 +639,7 @@ export function candidateFromSdp(sdp: string) {
         candidate.relatedAddress = bits[i + 1];
         break;
       case "rport":
-        candidate.relatedPort = parseInt(bits[i + 1]);
+        candidate.relatedPort = Number.parseInt(bits[i + 1]);
         break;
       case "tcptype":
         candidate.tcpType = bits[i + 1];
@@ -640,7 +651,10 @@ export function candidateFromSdp(sdp: string) {
 }
 
 export class RTCSessionDescription {
-  constructor(public sdp: string, public type: "offer" | "answer") {}
+  constructor(
+    public sdp: string,
+    public type: "offer" | "answer",
+  ) {}
   static isThis(o: any) {
     if (typeof o?.sdp === "string") return true;
   }

package/src/transport/dtls.ts

@@ -7,22 +7,22 @@ import { v4 } from "uuid";
 import {
   DtlsClient,
   DtlsServer,
-  DtlsSocket,
-  Transport,
+  type DtlsSocket,
+  type Transport,
 } from "../../../dtls/src";
 import {
   HashAlgorithm,
   NamedCurveAlgorithm,
   SignatureAlgorithm,
-  SignatureHash,
+  type SignatureHash,
 } from "../../../dtls/src/cipher/const";
 import { CipherContext } from "../../../dtls/src/context/cipher";
-import { Profile } from "../../../dtls/src/context/srtp";
-import { Connection } from "../../../ice/src";
+import type { Profile } from "../../../dtls/src/context/srtp";
+import type { Connection } from "../../../ice/src";
 import {
-  RtcpPacket,
+  type RtcpPacket,
   RtcpPacketConverter,
-  RtpHeader,
+  type RtpHeader,
   RtpPacket,
   SrtcpSession,
   SrtpSession,
@@ -30,10 +30,10 @@ import {
   isRtcp,
 } from "../../../rtp/src";
 import { keyLength, saltLength } from "../../../rtp/src/srtp/const";
-import { RtpRouter } from "../media/router";
-import { PeerConfig } from "../peerConnection";
+import type { RtpRouter } from "../media/router";
+import type { PeerConfig } from "../peerConnection";
 import { fingerprint, isDtls } from "../utils";
-import { RTCIceTransport } from "./ice";
+import type { RTCIceTransport } from "./ice";
 
 const log = debug("werift:packages/webrtc/src/transport/dtls.ts");
 
@@ -52,6 +52,7 @@ export class RTCDtlsTransport {
   readonly onStateChange = new Event<[DtlsState]>();
 
   localCertificate?: RTCCertificate;
+  localCertificatePromise?: Promise<RTCCertificate>;
   private remoteParameters?: RTCDtlsParameters;
 
   constructor(
@@ -72,7 +73,15 @@ export class RTCDtlsTransport {
   }
 
   async setupCertificate() {
-    if (!this.localCertificate) {
+    if (this.localCertificate) {
+      return this.localCertificate;
+    }
+
+    if (this.localCertificatePromise) {
+      return this.localCertificatePromise;
+    }
+
+    this.localCertificatePromise = (async () => {
       const { certPem, keyPem, signatureHash } =
         await CipherContext.createSelfSignedCertificateWithKey(
           {
@@ -86,8 +95,10 @@ export class RTCDtlsTransport {
         certPem,
         signatureHash,
       );
-    }
-    return this.localCertificate;
+      return this.localCertificate;
+    })();
+
+    return this.localCertificatePromise;
   }
 
   setRemoteParams(remoteParameters: RTCDtlsParameters) {
@@ -329,7 +340,10 @@ export type DtlsKeys = {
 };
 
 export class RTCDtlsFingerprint {
-  constructor(public algorithm: string, public value: string) {}
+  constructor(
+    public algorithm: string,
+    public value: string,
+  ) {}
 }
 
 export class RTCDtlsParameters {