werift 0.15.11 → 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,7 +5,16 @@ import Event from "rx.mini";
 import * as uuid from "uuid";
 
 import { Profile } from "../../dtls/src/context/srtp";
-import { deepMerge, InterfaceAddresses, Recvonly, Sendonly, Sendrecv } 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,
@@ -88,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>;
@@ -258,7 +268,7 @@ export class RTCPeerConnection extends EventTarget {
       }
       if (transceiver.headerExtensions.length === 0) {
         transceiver.headerExtensions =
-          this.config.headerExtensions[transceiver.kind];
+          this.config.headerExtensions[transceiver.kind] ?? [];
       }
     });
 
@@ -436,6 +446,9 @@ export class RTCPeerConnection extends EventTarget {
       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;
@@ -1060,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);
   }
@@ -1508,6 +1522,13 @@ export interface PeerConfig {
   /**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;
   }>;
@@ -1572,6 +1593,9 @@ export const defaultPeerConfig: PeerConfig = {
   iceServers: [{ urls: "stun:stun.l.google.com:19302" }],
   icePortRange: undefined,
   iceInterfaceAddresses: undefined,
+  iceUseIpv4: true,
+  iceUseIpv6: true,
+  iceFilterStunResponse: undefined,
   dtls: {},
   bundlePolicy: "max-compat",
   debug: {},