werift 0.19.3 → 0.19.5

package/src/transport/ice.ts

@@ -2,7 +2,7 @@ import debug from "debug";
 import Event from "rx.mini";
 import { v4 } from "uuid";
 
-import { Candidate, Connection, IceOptions } from "../../../ice/src";
+import { Candidate, Connection, type IceOptions } from "../../../ice/src";
 import { candidateFromSdp, candidateToSdp } from "../sdp";
 
 const log = debug("werift:packages/webrtc/src/transport/ice.ts");

package/src/transport/sctp.ts

@@ -3,7 +3,7 @@ import debug from "debug";
 import { Event } from "rx.mini";
 import * as uuid from "uuid";
 
-import { SCTP, SCTP_STATE, Transport } from "../../../sctp/src";
+import { SCTP, SCTP_STATE, type Transport } from "../../../sctp/src";
 import {
   DATA_CHANNEL_ACK,
   DATA_CHANNEL_OPEN,
@@ -15,11 +15,11 @@ import {
   WEBRTC_STRING_EMPTY,
 } from "../const";
 import {
-  DCState,
+  type DCState,
   RTCDataChannel,
   RTCDataChannelParameters,
 } from "../dataChannel";
-import { RTCDtlsTransport } from "./dtls";
+import type { RTCDtlsTransport } from "./dtls";
 
 const log = debug("werift:packages/webrtc/src/transport/sctp.ts");
 
@@ -108,73 +108,81 @@ export class RTCSctpTransport {
     if (ppId === WEBRTC_DCEP && data.length > 0) {
       log("DCEP", streamId, ppId, data);
       switch (data[0]) {
-        case DATA_CHANNEL_OPEN: {
-          if (data.length < 12) {
-            log("DATA_CHANNEL_OPEN data.length not enough");
-            return;
-          }
+        case DATA_CHANNEL_OPEN:
+          {
+            if (data.length < 12) {
+              log("DATA_CHANNEL_OPEN data.length not enough");
+              return;
+            }
 
-          if (!Object.keys(this.dataChannels).includes(streamId.toString())) {
-            const [, channelType, , reliability, labelLength, protocolLength] =
-              jspack.Unpack("!BBHLHH", data);
-
-            let pos = 12;
-            const label = data.slice(pos, pos + labelLength).toString("utf8");
-            pos += labelLength;
-            const protocol = data
-              .slice(pos, pos + protocolLength)
-              .toString("utf8");
-
-            log("DATA_CHANNEL_OPEN", {
-              channelType,
-              reliability,
-              streamId,
-              label,
-              protocol,
-            });
-
-            const maxRetransmits =
-              (channelType & 0x03) === 1 ? reliability : undefined;
-            const maxPacketLifeTime =
-              (channelType & 0x03) === 2 ? reliability : undefined;
-
-            // # register channel
-            const parameters = new RTCDataChannelParameters({
-              label,
-              ordered: (channelType & 0x80) === 0,
-              maxPacketLifeTime,
-              maxRetransmits,
-              protocol,
-              id: streamId,
-            });
-            const channel = new RTCDataChannel(this, parameters, false);
-            channel.isCreatedByRemote = true;
-            this.dataChannels[streamId] = channel;
-
-            this.onDataChannel.execute(channel);
-            channel.setReadyState("open");
-          } else {
-            log("datachannel already opened", "retransmit ack");
-          }
+            if (!Object.keys(this.dataChannels).includes(streamId.toString())) {
+              const [
+                ,
+                channelType,
+                ,
+                reliability,
+                labelLength,
+                protocolLength,
+              ] = jspack.Unpack("!BBHLHH", data);
+
+              let pos = 12;
+              const label = data.slice(pos, pos + labelLength).toString("utf8");
+              pos += labelLength;
+              const protocol = data
+                .slice(pos, pos + protocolLength)
+                .toString("utf8");
+
+              log("DATA_CHANNEL_OPEN", {
+                channelType,
+                reliability,
+                streamId,
+                label,
+                protocol,
+              });
+
+              const maxRetransmits =
+                (channelType & 0x03) === 1 ? reliability : undefined;
+              const maxPacketLifeTime =
+                (channelType & 0x03) === 2 ? reliability : undefined;
+
+              // # register channel
+              const parameters = new RTCDataChannelParameters({
+                label,
+                ordered: (channelType & 0x80) === 0,
+                maxPacketLifeTime,
+                maxRetransmits,
+                protocol,
+                id: streamId,
+              });
+              const channel = new RTCDataChannel(this, parameters, false);
+              channel.isCreatedByRemote = true;
+              this.dataChannels[streamId] = channel;
+
+              this.onDataChannel.execute(channel);
+              channel.setReadyState("open");
+            } else {
+              log("datachannel already opened", "retransmit ack");
+            }
 
-          const channel = this.dataChannels[streamId];
-          this.dataChannelQueue.push([
-            channel,
-            WEBRTC_DCEP,
-            Buffer.from(jspack.Pack("!B", [DATA_CHANNEL_ACK])),
-          ]);
-          await this.dataChannelFlush();
-        }
-        break;
-        case DATA_CHANNEL_ACK: {
-          log("DATA_CHANNEL_ACK", streamId, ppId);
-          const channel = this.dataChannels[streamId];
-          if (!channel) {
-            throw new Error("channel not found");
+            const channel = this.dataChannels[streamId];
+            this.dataChannelQueue.push([
+              channel,
+              WEBRTC_DCEP,
+              Buffer.from(jspack.Pack("!B", [DATA_CHANNEL_ACK])),
+            ]);
+            await this.dataChannelFlush();
           }
-          channel.setReadyState("open");
-        }
-        break;
+          break;
+        case DATA_CHANNEL_ACK:
+          {
+            log("DATA_CHANNEL_ACK", streamId, ppId);
+            const channel = this.dataChannels[streamId];
+            if (!channel) {
+              throw new Error("channel not found");
+            }
+            channel.setReadyState("open");
+          }
+          break;
       }
     } else {
       const channel = this.dataChannels[streamId];

package/src/utils.ts

@@ -7,10 +7,10 @@ import { performance } from "perf_hooks";
 
 import { bufferReader, bufferWriter, randomPort } from "../../common/src";
 import { CipherContext } from "../../dtls/src/context/cipher";
-import { Address } from "../../ice/src";
-import { Direction, Directions } from "./media/rtpTransceiver";
+import type { Address } from "../../ice/src";
+import { type Direction, Directions } from "./media/rtpTransceiver";
 import { MediaStreamTrack } from "./media/track";
-import { RTCIceServer } from "./peerConnection";
+import type { RTCIceServer } from "./peerConnection";
 const now = require("nano-time");
 
 const log = debug("werift:packages/webrtc/src/utils.ts");
@@ -76,7 +76,7 @@ export function parseIceServers(iceServers: RTCIceServer[]) {
   const url2Address = (url?: string) => {
     if (!url) return;
     const [address, port] = url.split(":");
-    return [address, parseInt(port)] as Address;
+    return [address, Number.parseInt(port)] as Address;
   };
 
   const stunServer = url2Address(
@@ -110,23 +110,30 @@ export class MediaStreamTrackFactory {
   static async rtpSource({
     port,
     kind,
+    cb,
   }: {
     port?: number;
     kind: "audio" | "video";
+    cb?: (buf: Buffer) => Buffer;
   }) {
     port ??= await randomPort();
     const track = new MediaStreamTrack({ kind });
 
     const udp = createSocket("udp4");
     udp.bind(port);
-    const onMessage = (msg: Buffer, rinfo: RemoteInfo) => {
+    const onMessage = (msg: Buffer) => {
+      if (cb) {
+        msg = cb(msg);
+      }
       track.writeRtp(msg);
     };
     udp.addListener("message", onMessage);
 
     const dispose = () => {
       udp.removeListener("message", onMessage);
-      udp.close();
+      try {
+        udp.close();
+      } catch (error) {}
     };
 
     return [track, port, dispose] as const;