werift 0.19.3 → 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();
@@ -49,6 +49,7 @@ export class MediaStreamTrack extends EventTarget {
     this.stopped = true;
     this.muted = true;
     this.onReceiveRtp.complete();
+    this.emit("ended");
   };
 
   writeRtp = (rtp: RtpPacket | Buffer) => {
@@ -70,8 +71,13 @@ export class MediaStream {
   id!: string;
   tracks: MediaStreamTrack[] = [];
 
-  constructor(props: Partial<MediaStream> & Pick<MediaStream, "id">) {
-    Object.assign(this, props);
+  constructor(props: Partial<MediaStream> | MediaStreamTrack[]) {
+    if (Array.isArray(props)) {
+      this.tracks = props;
+    } else {
+      Object.assign(this, props);
+    }
+    this.id ??= v4();
   }
 
   addTrack(track: MediaStreamTrack) {
@@ -82,4 +88,12 @@ export class MediaStream {
   getTracks() {
     return this.tracks;
   }
+
+  getAudioTracks() {
+    return this.tracks.filter((track) => track.kind === "audio");
+  }
+
+  getVideoTracks() {
+    return this.tracks.filter((track) => track.kind === "video");
+  }
 }

package/src/nonstandard/index.ts

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

package/src/nonstandard/navigator.ts

@@ -0,0 +1,118 @@
+import { randomBytes } from "crypto";
+import { jspack } from "@shinyoshiaki/jspack";
+import { MediaStream, MediaStreamTrack } from "../media/track";
+
+export class Navigator {
+  mediaDevices: MediaDevices;
+
+  constructor(props: ConstructorParameters<typeof MediaDevices>[0] = {}) {
+    this.mediaDevices = new MediaDevices(props);
+  }
+}
+
+export class MediaDevices extends EventTarget {
+  video?: MediaStreamTrack;
+  audio?: MediaStreamTrack;
+
+  constructor(
+    readonly props: { video?: MediaStreamTrack; audio?: MediaStreamTrack },
+  ) {
+    super();
+    this.video = props.video;
+    this.audio = props.audio;
+  }
+
+  readonly getUserMedia = async (
+    constraints: MediaStreamConstraints,
+  ): Promise<MediaStream> => {
+    const video = constraints.video
+      ? new MediaStreamTrack({ kind: "video" })
+      : undefined;
+    if (video) {
+      this.video?.onReceiveRtp.subscribe((rtp) => {
+        const cloned = rtp.clone();
+        cloned.header.ssrc = jspack.Unpack("!L", randomBytes(4))[0];
+        video.onReceiveRtp.execute(cloned);
+      });
+    }
+    const audio = constraints.audio
+      ? new MediaStreamTrack({ kind: "audio" })
+      : undefined;
+    if (audio) {
+      this.audio?.onReceiveRtp.subscribe((rtp) => {
+        const cloned = rtp.clone();
+        cloned.header.ssrc = jspack.Unpack("!L", randomBytes(4))[0];
+        audio.onReceiveRtp.execute(cloned);
+      });
+    }
+
+    if (constraints.video && constraints.audio) {
+      return new MediaStream([video!, audio!]);
+    } else if (constraints.audio) {
+      return new MediaStream([audio!]);
+    } else if (constraints.video) {
+      return new MediaStream([video!]);
+    }
+
+    throw new Error("Not implemented");
+  };
+
+  readonly getDisplayMedia = this.getUserMedia;
+}
+
+interface MediaStreamConstraints {
+  audio?: boolean | MediaTrackConstraints;
+  peerIdentity?: string;
+  preferCurrentTab?: boolean;
+  video?: boolean | MediaTrackConstraints;
+}
+
+interface MediaTrackConstraints extends MediaTrackConstraintSet {
+  advanced?: MediaTrackConstraintSet[];
+}
+
+interface MediaTrackConstraintSet {
+  aspectRatio?: ConstrainDouble;
+  autoGainControl?: ConstrainBoolean;
+  channelCount?: ConstrainULong;
+  deviceId?: ConstrainDOMString;
+  displaySurface?: ConstrainDOMString;
+  echoCancellation?: ConstrainBoolean;
+  facingMode?: ConstrainDOMString;
+  frameRate?: ConstrainDouble;
+  groupId?: ConstrainDOMString;
+  height?: ConstrainULong;
+  noiseSuppression?: ConstrainBoolean;
+  sampleRate?: ConstrainULong;
+  sampleSize?: ConstrainULong;
+  width?: ConstrainULong;
+}
+
+type ConstrainDOMString = string | string[] | ConstrainDOMStringParameters;
+interface ConstrainDOMStringParameters {
+  exact?: string | string[];
+  ideal?: string | string[];
+}
+type ConstrainBoolean = boolean | ConstrainBooleanParameters;
+interface ConstrainBooleanParameters {
+  exact?: boolean;
+  ideal?: boolean;
+}
+type ConstrainULong = number | ConstrainULongRange;
+interface ConstrainULongRange extends ULongRange {
+  exact?: number;
+  ideal?: number;
+}
+interface ULongRange {
+  max?: number;
+  min?: number;
+}
+type ConstrainDouble = number | ConstrainDoubleRange;
+interface ConstrainDoubleRange extends DoubleRange {
+  exact?: number;
+  ideal?: number;
+}
+interface DoubleRange {
+  max?: number;
+  min?: number;
+}

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[]) {}