werift 0.15.10 → 0.16.0

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

@@ -1,75 +1,123 @@
-import * as fs from "fs/promises";
+import { appendFile, open, unlink } from "fs/promises";
+import { ReadableStreamDefaultReadResult } from "stream/web";
 
 import { SupportedCodec } from "../../../../../rtp/src/container/webm";
 import {
-  JitterBuffer,
+  depacketizeTransformer,
+  jitterBufferTransformer,
   MediaStreamTrack,
-  SampleBuilder,
-  WebmOutput,
+  RtpSourceStream,
+  WebmLiveOutput,
+  WebmLiveSink,
+  WeriftError,
 } from "../../..";
 import { MediaWriter } from ".";
 
+const sourcePath = "packages/webrtc/src/nonstandard/recorder/writer/webm.ts";
+
 export class WebmFactory extends MediaWriter {
-  webm?: WebmOutput;
+  rtpSources: RtpSourceStream[] = [];
+
+  async start(tracks: MediaStreamTrack[]) {
+    await unlink(this.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.options.width,
+          height: this.options.height,
+          payloadType,
+          track,
+        };
+      } else {
+        return {
+          kind: "audio" as const,
+          codec: "OPUS" as const,
+          clockRate: 48000,
+          trackNumber,
+          payloadType,
+          track,
+        };
+      }
+    });
 
-  start(tracks: MediaStreamTrack[]) {
-    this.webm = new WebmOutput(
-      fs,
-      this.path,
-      tracks.map((track, i) => {
-        const trackNumber = i + 1;
-        const payloadType = track.codec!.payloadType;
+    const webm = new WebmLiveSink(inputTracks, {
+      duration: this.options.defaultDuration ?? 1000 * 60 * 60 * 24,
+    });
+
+    this.rtpSources = inputTracks.map(({ track, clockRate, codec }) => {
+      const rtpSource = new RtpSourceStream(track.onReceiveRtp);
+
+      const jitterBuffer = jitterBufferTransformer(clockRate, {
+        latency: this.options.jitterBufferLatency,
+        bufferSize: this.options.jitterBufferSize,
+      });
 
-        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 Error();
-            }
-          })();
-          return {
-            kind: "video",
-            clockRate: 90000,
-            payloadType,
-            trackNumber,
-            codec,
-            width: this.options.width,
-            height: this.options.height,
-          };
-        } else {
-          return {
-            kind: "audio",
-            clockRate: 48000,
-            payloadType,
-            trackNumber,
-            codec: "OPUS",
-          };
-        }
-      })
-    );
+      if (track.kind === "video") {
+        rtpSource.readable
+          .pipeThrough(jitterBuffer)
+          .pipeThrough(
+            depacketizeTransformer((h) => h.marker, codec, {
+              waitForKeyframe: this.options.waitForKeyframe,
+            })
+          )
+          .pipeTo(webm.videoStream);
+      } else {
+        rtpSource.readable
+          .pipeThrough(jitterBuffer)
+          .pipeThrough(depacketizeTransformer(() => true, codec))
+          .pipeTo(webm.audioStream);
+      }
 
-    tracks.forEach((track) => {
-      const sampleBuilder =
-        track.kind === "video"
-          ? new SampleBuilder((h) => !!h.marker).pipe(this.webm!)
-          : new SampleBuilder(() => true).pipe(this.webm!);
-      new JitterBuffer({
-        rtpStream: track.onReceiveRtp,
-        rtcpStream: track.onReceiveRtcp,
-      }).pipe(sampleBuilder);
+      return rtpSource;
     });
+
+    const reader = webm.webmStream.getReader();
+    const readChunk = async ({
+      value,
+      done,
+    }: ReadableStreamDefaultReadResult<WebmLiveOutput>) => {
+      if (done) return;
+
+      if (value.packet) {
+        await appendFile(this.path, value.packet);
+      } else if (value.eol) {
+        const { durationElement } = value.eol;
+        const handler = await open(this.path, "r+");
+        await handler.write(durationElement, 0, durationElement.length, 83);
+        await handler.close();
+      }
+      reader.read().then(readChunk);
+    };
+    reader.read().then(readChunk);
   }
 
   async stop() {
-    await this.webm!.stop();
+    await Promise.all(this.rtpSources.map((r) => r.stop()));
   }
 }
 

package/src/peerConnection.ts

@@ -5,11 +5,19 @@ import Event from "rx.mini";
 import * as uuid from "uuid";
 
 import { Profile } from "../../dtls/src/context/srtp";
-import { deepMerge } from ".";
+import { Message } from "../../ice/src/stun/message";
+import { Protocol } from "../../ice/src/types/model";
+import {
+  Address,
+  deepMerge,
+  InterfaceAddresses,
+  Recvonly,
+  Sendonly,
+  Sendrecv,
+} from ".";
 import {
   codecParametersFromString,
   DtlsKeys,
-  useAbsSendTime,
   useNACK,
   usePLI,
   useREMB,
@@ -22,8 +30,6 @@ import {
 } from "./const";
 import { RTCDataChannel, RTCDataChannelParameters } from "./dataChannel";
 import { enumerate, EventTarget } from "./helper";
-import { useFIR } from "./media/extension/rtcpFeedback";
-import { useSdesMid, useTransportWideCC } from "./media/extension/rtpExtension";
 import {
   RTCRtpCodecParameters,
   RTCRtpCodingParameters,
@@ -91,6 +97,7 @@ export class RTCPeerConnection extends EventTarget {
   readonly onTransceiverAdded = new Event<[RTCRtpTransceiver]>();
   readonly onIceCandidate = new Event<[RTCIceCandidate]>();
   readonly onNegotiationneeded = new Event<[]>();
+  readonly onTrack = new Event<[MediaStreamTrack]>();
 
   ondatachannel?: CallbackWithValue<RTCDataChannelEvent>;
   onicecandidate?: CallbackWithValue<RTCPeerConnectionIceEvent>;
@@ -226,14 +233,42 @@ export class RTCPeerConnection extends EventTarget {
     return description.toJSON();
   }
 
+  private assignTransceiverCodecs(transceiver: RTCRtpTransceiver) {
+    const codecs = (
+      this.config.codecs[transceiver.kind] as RTCRtpCodecParameters[]
+    ).filter((codecCandidate) => {
+      switch (codecCandidate.direction) {
+        case "recvonly": {
+          if ([Recvonly, Sendrecv].includes(transceiver.direction)) return true;
+          return false;
+        }
+        case "sendonly": {
+          if ([Sendonly, Sendrecv].includes(transceiver.direction)) return true;
+          return false;
+        }
+        case "sendrecv": {
+          if ([Sendrecv, Recvonly, Sendonly].includes(transceiver.direction))
+            return true;
+          return false;
+        }
+        case "all": {
+          return true;
+        }
+        default:
+          return false;
+      }
+    });
+    transceiver.codecs = codecs;
+  }
+
   buildOfferSdp() {
     this.transceivers.forEach((transceiver) => {
       if (transceiver.codecs.length === 0) {
-        transceiver.codecs = this.config.codecs[transceiver.kind];
+        this.assignTransceiverCodecs(transceiver);
       }
       if (transceiver.headerExtensions.length === 0) {
         transceiver.headerExtensions =
-          this.config.headerExtensions[transceiver.kind];
+          this.config.headerExtensions[transceiver.kind] ?? [];
       }
     });
 
@@ -410,6 +445,10 @@ export class RTCPeerConnection extends EventTarget {
       ...parseIceServers(this.config.iceServers),
       forceTurn: this.config.iceTransportPolicy === "relay",
       portRange: this.config.icePortRange,
+      interfaceAddresses: this.config.iceInterfaceAddresses,
+      filterStunResponse: this.config.iceFilterStunResponse,
+      useIpv4: this.config.iceUseIpv4,
+      useIpv6: this.config.iceUseIpv6,
     });
     if (existing) {
       iceGatherer.connection.localUserName = existing.connection.localUserName;
@@ -1034,6 +1073,7 @@ export class RTCPeerConnection extends EventTarget {
       transceiver,
       receiver: transceiver.receiver,
     };
+    this.onTrack.execute(track);
     this.emit("track", event);
     if (this.ontrack) this.ontrack(event);
   }
@@ -1053,7 +1093,7 @@ export class RTCPeerConnection extends EventTarget {
     ]);
 
     const sender = new RTCRtpSender(trackOrKind);
-    const receiver = new RTCRtpReceiver(kind, sender.ssrc);
+    const receiver = new RTCRtpReceiver(this.config, kind, sender.ssrc);
     const transceiver = new RTCRtpTransceiver(
       kind,
       dtlsTransport,
@@ -1481,6 +1521,14 @@ export interface PeerConfig {
   iceServers: RTCIceServer[];
   /**Minimum port and Maximum port must not be the same value */
   icePortRange: [number, number] | undefined;
+  iceInterfaceAddresses: InterfaceAddresses | undefined;
+  iceUseIpv4: boolean;
+  iceUseIpv6: 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:
+    | ((message: Message, addr: Address, protocol: Protocol) => boolean)
+    | undefined;
   dtls: Partial<{
     keys: DtlsKeys;
   }>;
@@ -1492,6 +1540,8 @@ export interface PeerConfig {
     outboundPacketLoss: number;
     /**ms */
     receiverReportDelay: number;
+    disableSendNack: boolean;
+    disableRecvRetransmit: boolean;
   }>;
 }
 
@@ -1542,6 +1592,10 @@ export const defaultPeerConfig: PeerConfig = {
   iceTransportPolicy: "all",
   iceServers: [{ urls: "stun:stun.l.google.com:19302" }],
   icePortRange: undefined,
+  iceInterfaceAddresses: undefined,
+  iceUseIpv4: true,
+  iceUseIpv6: true,
+  iceFilterStunResponse: undefined,
   dtls: {},
   bundlePolicy: "max-compat",
   debug: {},

package/src/sdp.ts

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

package/src/transport/dtls.ts

@@ -202,7 +202,11 @@ export class RTCDtlsTransport {
       } else {
         const dec = this.srtp.decrypt(data);
         const rtp = RtpPacket.deSerialize(dec);
-        this.router.routeRtp(rtp);
+        try {
+          this.router.routeRtp(rtp);
+        } catch (error) {
+          log("router error", error);
+        }
       }
     });
   }

package/src/transport/sctp.ts

@@ -21,7 +21,7 @@ import {
 } from "../dataChannel";
 import { RTCDtlsTransport } from "./dtls";
 
-const log = debug("werift/webrtc/transport/sctp");
+const log = debug("werift:packages/webrtc/src/transport/sctp.ts");
 
 export class RTCSctpTransport {
   dtlsTransport!: RTCDtlsTransport;

package/src/utils.ts

@@ -18,7 +18,7 @@ import { Direction, Directions } from "./media/rtpTransceiver";
 import { RTCIceServer } from "./peerConnection";
 const now = require("nano-time");
 
-const log = debug("werift/webrtc/utils");
+const log = debug("werift:packages/webrtc/src/utils.ts");
 
 export function fingerprint(file: Buffer, hashName: string) {
   const upper = (s: string) => s.toUpperCase();
@@ -64,6 +64,8 @@ export const microTime = () => now.micro() as number;
 
 export const milliTime = () => new Date().getTime();
 
+export const timestampSeconds = () => Date.now() / 1000;
+
 /**https://datatracker.ietf.org/doc/html/rfc3550#section-4 */
 export const ntpTime = () => {
   const now = performance.timeOrigin + performance.now() - Date.UTC(1900, 0, 1);
@@ -76,7 +78,11 @@ export const ntpTime = () => {
   return buf.readBigUInt64BE();
 };
 
-/**https://datatracker.ietf.org/doc/html/rfc3550#section-4 */
+/**
+ * https://datatracker.ietf.org/doc/html/rfc3550#section-4
+ * @param ntp
+ * @returns 32bit
+ */
 export const compactNtp = (ntp: bigint) => {
   const buf = bufferWriter([8], [ntp]);
   const [, sec, msec] = bufferReader(buf, [2, 2, 2, 2]);