werift 0.19.4 → 0.19.5

package/src/media/rtpReceiver.ts

@@ -3,31 +3,39 @@ import Event from "rx.mini";
 import { setTimeout } from "timers/promises";
 import { v4 as uuid } from "uuid";
 
-import { PeerConfig, codecParametersFromString, usePLI, useTWCC } from "..";
+import {
+  type PeerConfig,
+  codecParametersFromString,
+  usePLI,
+  useTWCC,
+} from "..";
 import { int } from "../../../common/src";
 import {
   PictureLossIndication,
   RTP_EXTENSION_URI,
   Red,
   RedHandler,
-  RtcpPacket,
+  type RtcpPacket,
   RtcpPayloadSpecificFeedback,
   RtcpReceiverInfo,
   RtcpRrPacket,
   RtcpSrPacket,
-  RtpPacket,
-  TransportWideCCPayload,
+  type RtpPacket,
+  type TransportWideCCPayload,
   unwrapRtx,
 } from "../../../rtp/src";
-import { RTCDtlsTransport } from "../transport/dtls";
-import { Kind } from "../types/domain";
+import type { RTCDtlsTransport } from "../transport/dtls";
+import type { Kind } from "../types/domain";
 import { compactNtp, timestampSeconds } from "../utils";
-import { RTCRtpCodecParameters, RTCRtpReceiveParameters } from "./parameters";
+import type {
+  RTCRtpCodecParameters,
+  RTCRtpReceiveParameters,
+} from "./parameters";
 import { NackHandler } from "./receiver/nack";
 import { ReceiverTWCC } from "./receiver/receiverTwcc";
 import { StreamStatistics } from "./receiver/statistics";
-import { Extensions } from "./router";
-import { MediaStreamTrack } from "./track";
+import type { Extensions } from "./router";
+import type { MediaStreamTrack } from "./track";
 
 const log = debug("werift:packages/webrtc/src/media/rtpReceiver.ts");
 
@@ -236,17 +244,20 @@ export class RTCRtpReceiver {
 
   handleRtcpPacket(packet: RtcpPacket) {
     switch (packet.type) {
-      case RtcpSrPacket.type: {
-        const sr = packet as RtcpSrPacket;
-        this.lastSRtimestamp[sr.ssrc] = compactNtp(sr.senderInfo.ntpTimestamp);
-        this.receiveLastSRTimestamp[sr.ssrc] = timestampSeconds();
-
-        const track = this.trackBySSRC[packet.ssrc];
-        if (track) {
-          track.onReceiveRtcp.execute(packet);
+      case RtcpSrPacket.type:
+        {
+          const sr = packet as RtcpSrPacket;
+          this.lastSRtimestamp[sr.ssrc] = compactNtp(
+            sr.senderInfo.ntpTimestamp,
+          );
+          this.receiveLastSRTimestamp[sr.ssrc] = timestampSeconds();
+
+          const track = this.trackBySSRC[packet.ssrc];
+          if (track) {
+            track.onReceiveRtcp.execute(packet);
+          }
         }
-      }
-      break;
+        break;
     }
     this.onRtcp.execute(packet);
   }

package/src/media/rtpSender.ts

@@ -30,20 +30,20 @@ import * as uuid from "uuid";
 import { codecParametersFromString } from "..";
 import { random16, uint16Add, uint32Add } from "../../../common/src";
 import {
-  Extension,
+  type Extension,
   GenericNack,
   PictureLossIndication,
   RTP_EXTENSION_URI,
   ReceiverEstimatedMaxBitrate,
   RedEncoder,
-  RtcpPacket,
+  type RtcpPacket,
   RtcpPayloadSpecificFeedback,
   RtcpRrPacket,
   RtcpSenderInfo,
   RtcpSourceDescriptionPacket,
   RtcpSrPacket,
   RtcpTransportLayerFeedback,
-  RtpHeader,
+  type RtpHeader,
   RtpPacket,
   SourceDescriptionChunk,
   SourceDescriptionItem,
@@ -55,16 +55,16 @@ import {
   serializeTransportWideCC,
   wrapRtx,
 } from "../../../rtp/src";
-import { RTCDtlsTransport } from "../transport/dtls";
-import { Kind } from "../types/domain";
+import type { RTCDtlsTransport } from "../transport/dtls";
+import type { Kind } from "../types/domain";
 import { compactNtp, milliTime, ntpTime, timestampSeconds } from "../utils";
-import {
+import type {
   RTCRtpCodecParameters,
   RTCRtpHeaderExtensionParameters,
   RTCRtpSendParameters,
 } from "./parameters";
-import { SenderBandwidthEstimator, SentInfo } from "./sender/senderBWE";
-import { MediaStreamTrack } from "./track";
+import { SenderBandwidthEstimator, type SentInfo } from "./sender/senderBWE";
+import type { MediaStreamTrack } from "./track";
 
 const log = debug("werift:packages/webrtc/src/media/rtpSender.ts");
 
@@ -410,77 +410,90 @@ export class RTCRtpSender {
   handleRtcpPacket(rtcpPacket: RtcpPacket) {
     switch (rtcpPacket.type) {
       case RtcpSrPacket.type:
-      case RtcpRrPacket.type: {
-        const packet = rtcpPacket as RtcpSrPacket | RtcpRrPacket;
-        packet.reports
-          .filter((report) => report.ssrc === this.ssrc)
-          .forEach((report) => {
-            if (this.lastSRtimestamp === report.lsr && report.dlsr) {
-              if (this.lastSentSRTimestamp) {
-                const rtt =
-                  timestampSeconds() -
-                  this.lastSentSRTimestamp -
-                  report.dlsr / 65536;
-                if (this.rtt === undefined) {
-                  this.rtt = rtt;
-                } else {
-                  this.rtt = RTT_ALPHA * this.rtt + (1 - RTT_ALPHA) * rtt;
+      case RtcpRrPacket.type:
+        {
+          const packet = rtcpPacket as RtcpSrPacket | RtcpRrPacket;
+          packet.reports
+            .filter((report) => report.ssrc === this.ssrc)
+            .forEach((report) => {
+              if (this.lastSRtimestamp === report.lsr && report.dlsr) {
+                if (this.lastSentSRTimestamp) {
+                  const rtt =
+                    timestampSeconds() -
+                    this.lastSentSRTimestamp -
+                    report.dlsr / 65536;
+                  if (this.rtt === undefined) {
+                    this.rtt = rtt;
+                  } else {
+                    this.rtt = RTT_ALPHA * this.rtt + (1 - RTT_ALPHA) * rtt;
+                  }
                 }
               }
-            }
-          });
-      }
-      break;
-      case RtcpTransportLayerFeedback.type: {
-        const packet = rtcpPacket as RtcpTransportLayerFeedback;
-        switch (packet.feedback.count) {
-          case TransportWideCC.count: {
-            const feedback = packet.feedback as TransportWideCC;
-            this.senderBWE.receiveTWCC(feedback);
-          }
-          break;
-          case GenericNack.count: {
-            const feedback = packet.feedback as GenericNack;
-            feedback.lost.forEach(async (seqNum) => {
-              let packet: RtpPacket | undefined =
-                this.rtpCache[seqNum % RTP_HISTORY_SIZE];
-              if (packet && packet.header.sequenceNumber !== seqNum) {
-                packet = undefined;
+            });
+        }
+        break;
+      case RtcpTransportLayerFeedback.type:
+        {
+          const packet = rtcpPacket as RtcpTransportLayerFeedback;
+          switch (packet.feedback.count) {
+            case TransportWideCC.count:
+              {
+                const feedback = packet.feedback as TransportWideCC;
+                this.senderBWE.receiveTWCC(feedback);
               }
-              if (packet) {
-                if (this.rtxPayloadType != undefined) {
-                  packet = wrapRtx(
-                    packet,
-                    this.rtxPayloadType,
-                    this.rtxSequenceNumber,
-                    this.rtxSsrc,
-                  );
-                  this.rtxSequenceNumber = uint16Add(this.rtxSequenceNumber, 1);
-                }
-                await this.dtlsTransport.sendRtp(packet.payload, packet.header);
+              break;
+            case GenericNack.count:
+              {
+                const feedback = packet.feedback as GenericNack;
+                feedback.lost.forEach(async (seqNum) => {
+                  let packet: RtpPacket | undefined =
+                    this.rtpCache[seqNum % RTP_HISTORY_SIZE];
+                  if (packet && packet.header.sequenceNumber !== seqNum) {
+                    packet = undefined;
+                  }
+                  if (packet) {
+                    if (this.rtxPayloadType != undefined) {
+                      packet = wrapRtx(
+                        packet,
+                        this.rtxPayloadType,
+                        this.rtxSequenceNumber,
+                        this.rtxSsrc,
+                      );
+                      this.rtxSequenceNumber = uint16Add(
+                        this.rtxSequenceNumber,
+                        1,
+                      );
+                    }
+                    await this.dtlsTransport.sendRtp(
+                      packet.payload,
+                      packet.header,
+                    );
+                  }
+                });
+                this.onGenericNack.execute(feedback);
               }
-            });
-            this.onGenericNack.execute(feedback);
+              break;
           }
-          break;
         }
-      }
-      break;
-      case RtcpPayloadSpecificFeedback.type: {
-        const packet = rtcpPacket as RtcpPayloadSpecificFeedback;
-        switch (packet.feedback.count) {
-          case ReceiverEstimatedMaxBitrate.count: {
-            const feedback = packet.feedback as ReceiverEstimatedMaxBitrate;
-            this.receiverEstimatedMaxBitrate = feedback.bitrate;
-          }
-          break;
-          case PictureLossIndication.count: {
-            this.onPictureLossIndication.execute();
+        break;
+      case RtcpPayloadSpecificFeedback.type:
+        {
+          const packet = rtcpPacket as RtcpPayloadSpecificFeedback;
+          switch (packet.feedback.count) {
+            case ReceiverEstimatedMaxBitrate.count:
+              {
+                const feedback = packet.feedback as ReceiverEstimatedMaxBitrate;
+                this.receiverEstimatedMaxBitrate = feedback.bitrate;
+              }
+              break;
+            case PictureLossIndication.count:
+              {
+                this.onPictureLossIndication.execute();
+              }
+              break;
           }
-          break;
         }
-      }
-      break;
+        break;
     }
     this.onRtcp.execute(rtcpPacket);
   }

package/src/media/rtpTransceiver.ts

@@ -1,16 +1,16 @@
 import Event from "rx.mini";
 import * as uuid from "uuid";
 
-import { RTCDtlsTransport } from "..";
+import type { RTCDtlsTransport } from "..";
 import { SenderDirections } from "../const";
-import { Kind } from "../types/domain";
-import {
+import type { Kind } from "../types/domain";
+import type {
   RTCRtpCodecParameters,
   RTCRtpHeaderExtensionParameters,
 } from "./parameters";
-import { RTCRtpReceiver } from "./rtpReceiver";
-import { RTCRtpSender } from "./rtpSender";
-import { MediaStreamTrack } from "./track";
+import type { RTCRtpReceiver } from "./rtpReceiver";
+import type { RTCRtpSender } from "./rtpSender";
+import type { MediaStreamTrack } from "./track";
 
 export class RTCRtpTransceiver {
   readonly id = uuid.v4();

package/src/media/sender/senderBWE.ts

@@ -1,6 +1,6 @@
 import Event from "rx.mini";
 
-import { TransportWideCC } from "../../../../rtp/src";
+import type { TransportWideCC } from "../../../../rtp/src";
 import { Int } from "../../../../rtp/src/helper";
 import { milliTime } from "../../utils";
 import { CumulativeResult } from "./cumulativeResult";

package/src/media/track.ts

@@ -1,10 +1,10 @@
 import Event from "rx.mini";
 import { v4 } from "uuid";
 
-import { RtcpPacket, RtpHeader, RtpPacket } from "../../../rtp/src";
+import { type RtcpPacket, type RtpHeader, RtpPacket } from "../../../rtp/src";
 import { EventTarget } from "../helper";
-import { Kind } from "../types/domain";
-import { RTCRtpCodecParameters } from "./parameters";
+import type { Kind } from "../types/domain";
+import type { RTCRtpCodecParameters } from "./parameters";
 
 export class MediaStreamTrack extends EventTarget {
   readonly uuid = v4();

package/src/nonstandard/index.ts

@@ -1,3 +1,4 @@
 export * from "./recorder";
 export * from "./userMedia";
 export * from "./navigator";
+export * from "../../../rtp/src/extra";

package/src/nonstandard/navigator.ts

@@ -14,7 +14,9 @@ export class MediaDevices extends EventTarget {
   video?: MediaStreamTrack;
   audio?: MediaStreamTrack;
 
-  constructor(props: { video?: MediaStreamTrack; audio?: MediaStreamTrack }) {
+  constructor(
+    readonly props: { video?: MediaStreamTrack; audio?: MediaStreamTrack },
+  ) {
     super();
     this.video = props.video;
     this.audio = props.audio;

package/src/nonstandard/recorder/index.ts

@@ -1,37 +1,61 @@
 import Event from "rx.mini";
 
-import { MediaStreamTrack } from "../../media/track";
-import { MediaWriter } from "./writer";
+import type { PassThrough } from "stream";
+import type { MediaStreamTrack } from "../../media/track";
+import type { MediaWriter } from "./writer";
 import { WebmFactory } from "./writer/webm";
 
 export class MediaRecorder {
   writer: MediaWriter;
-  ext: string;
+  ext?: string;
   tracks: MediaStreamTrack[] = [];
   started = false;
   onError = new Event<[Error]>();
 
   constructor(
-    public path: string,
-    public numOfTracks = 1,
-    public options: Partial<MediaRecorderOptions> = {},
+    public props: Partial<MediaRecorderOptions> & {
+      numOfTracks: number;
+    } & (
+        | {
+            path: string;
+            stream?: PassThrough;
+          }
+        | {
+            path?: string;
+            stream: PassThrough;
+          }
+      ),
   ) {
-    this.ext = path.split(".").slice(-1)[0];
-    this.writer = (() => {
-      switch (this.ext) {
-        case "webm":
-          return new WebmFactory(path, options);
-        default:
-          throw new Error();
-      }
-    })();
-
-    this.tracks = options.tracks ?? this.tracks;
-    if (this.tracks.length === numOfTracks) {
+    this.tracks = props.tracks ?? this.tracks;
+    if (this.tracks.length === props.numOfTracks) {
       this.start().catch((error) => {
         this.onError.execute(error);
       });
     }
+
+    const { path, stream } = props;
+
+    if (path) {
+      this.ext = path.split(".").slice(-1)[0];
+      this.writer = (() => {
+        switch (this.ext) {
+          case "webm":
+            return new WebmFactory({
+              ...props,
+              path: path!,
+              stream: stream!,
+            });
+          default:
+            throw new Error();
+        }
+      })();
+    } else {
+      this.writer = new WebmFactory({
+        ...props,
+        path: path!,
+        stream: stream!,
+      });
+    }
   }
 
   async addTrack(track: MediaStreamTrack) {
@@ -40,7 +64,10 @@ export class MediaRecorder {
   }
 
   private async start() {
-    if (this.tracks.length === this.numOfTracks && this.started === false) {
+    if (
+      this.tracks.length === this.props.numOfTracks &&
+      this.started === false
+    ) {
       this.started = true;
       await this.writer.start(this.tracks);
     }
@@ -59,4 +86,5 @@ export interface MediaRecorderOptions {
   waitForKeyframe: boolean;
   defaultDuration: number;
   tracks: MediaStreamTrack[];
+  disableNtp: boolean;
 }

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

@@ -1,10 +1,13 @@
-import { MediaRecorderOptions } from "..";
-import { MediaStreamTrack } from "../../..";
+import type { PassThrough } from "stream";
+import type { MediaRecorderOptions } from "..";
+import type { MediaStreamTrack } from "../../..";
 
 export abstract class MediaWriter {
   constructor(
-    protected path: string,
-    protected options: Partial<MediaRecorderOptions>,
+    protected props: Partial<MediaRecorderOptions> & {
+      path: string;
+      stream?: PassThrough;
+    } & { path?: string; stream: PassThrough },
   ) {}
 
   async start(tracks: MediaStreamTrack[]) {}

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";