werift 0.19.0 → 0.19.2

package/src/media/rtpSender.ts

@@ -21,17 +21,19 @@ Figure 2: Example for round-trip time computation
  */
 
 import { randomBytes } from "crypto";
+import { jspack } from "@shinyoshiaki/jspack";
 import debug from "debug";
-import { jspack } from "jspack";
 import Event from "rx.mini";
 import { setTimeout } from "timers/promises";
 import * as uuid from "uuid";
 
+import { codecParametersFromString } from "..";
 import { random16, uint16Add, uint32Add } from "../../../common/src";
 import {
   Extension,
   GenericNack,
   PictureLossIndication,
+  RTP_EXTENSION_URI,
   ReceiverEstimatedMaxBitrate,
   RedEncoder,
   RtcpPacket,
@@ -41,20 +43,18 @@ import {
   RtcpSourceDescriptionPacket,
   RtcpSrPacket,
   RtcpTransportLayerFeedback,
-  RTP_EXTENSION_URI,
   RtpHeader,
   RtpPacket,
+  SourceDescriptionChunk,
+  SourceDescriptionItem,
+  TransportWideCC,
   serializeAbsSendTime,
   serializeRepairedRtpStreamId,
   serializeSdesMid,
   serializeSdesRTPStreamID,
   serializeTransportWideCC,
-  SourceDescriptionChunk,
-  SourceDescriptionItem,
-  TransportWideCC,
   wrapRtx,
 } from "../../../rtp/src";
-import { codecParametersFromString } from "..";
 import { RTCDtlsTransport } from "../transport/dtls";
 import { Kind } from "../types/domain";
 import { compactNtp, milliTime, ntpTime, timestampSeconds } from "../utils";
@@ -104,7 +104,7 @@ export class RTCRtpSender {
   private octetCount = 0;
   private packetCount = 0;
   private rtt?: number;
-  receiverEstimatedMaxBitrate: bigint = 0n;
+  receiverEstimatedMaxBitrate = 0n;
 
   // rtp
   private sequenceNumber?: number;
@@ -410,90 +410,77 @@ 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 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 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);
+              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;
+            });
+            this.onGenericNack.execute(feedback);
           }
+          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;
+      }
+      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;
     }
     this.onRtcp.execute(rtcpPacket);
   }

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

@@ -1,5 +1,5 @@
-import { MediaStreamTrack } from "../../..";
 import { MediaRecorderOptions } from "..";
+import { MediaStreamTrack } from "../../..";
 
 export abstract class MediaWriter {
   constructor(

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

@@ -1,6 +1,8 @@
 import { unlink } from "fs/promises";
 import { EventDisposer } from "rx.mini";
 
+import { MediaWriter } from ".";
+import { MediaStreamTrack, WeriftError } from "../../..";
 import {
   DepacketizeCallback,
   JitterBufferCallback,
@@ -8,12 +10,10 @@ import {
   NtpTimeCallback,
   RtcpSourceCallback,
   RtpSourceCallback,
-  saveToFileSystem,
   SupportedCodec,
   WebmCallback,
+  saveToFileSystem,
 } from "../../../../../rtp/src/extra";
-import { MediaStreamTrack, WeriftError } from "../../..";
-import { MediaWriter } from ".";
 
 const sourcePath = "packages/webrtc/src/nonstandard/recorder/writer/webm.ts";
 

package/src/nonstandard/userMedia.ts

@@ -134,9 +134,7 @@ export class MediaPlayerWebm extends MediaPlayer {
     const run = async () => {
       if (payloadType > 100) payloadType = 96;
 
-      const cmd = `gst-launch-1.0 filesrc location=${
-        this.props.path
-      } ! matroskademux name=d \
+      const cmd = `gst-launch-1.0 filesrc location=${this.props.path} ! matroskademux name=d \
 d.video_0 ! queue ! rtpvp8pay pt=${payloadType++} ! \
 udpsink host=127.0.0.1 port=${this.props.videoPort} \
 d.audio_0 ! queue ! rtpopuspay pt=${payloadType++} ! \

package/src/peerConnection.ts

@@ -4,34 +4,34 @@ import isEqual from "lodash/isEqual";
 import Event from "rx.mini";
 import * as uuid from "uuid";
 
-import { Profile } from "../../dtls/src/context/srtp";
-import { Message } from "../../ice/src/stun/message";
-import { Protocol } from "../../ice/src/types/model";
 import {
   Address,
   CandidatePair,
-  deepMerge,
   InterfaceAddresses,
   Recvonly,
   Sendonly,
   Sendrecv,
+  deepMerge,
 } from ".";
 import {
-  codecParametersFromString,
   DtlsKeys,
+  codecParametersFromString,
   useNACK,
   usePLI,
   useREMB,
 } from ".";
+import { Profile } from "../../dtls/src/context/srtp";
+import { Message } from "../../ice/src/stun/message";
+import { Protocol } from "../../ice/src/types/model";
 import {
   DISCARD_HOST,
   DISCARD_PORT,
   ReceiverDirection,
-  SenderDirections,
   SRTP_PROFILE,
+  SenderDirections,
 } from "./const";
 import { RTCDataChannel, RTCDataChannelParameters } from "./dataChannel";
-import { enumerate, EventTarget } from "./helper";
+import { EventTarget, enumerate } from "./helper";
 import {
   RTCRtpCodecParameters,
   RTCRtpCodingParameters,
@@ -51,11 +51,11 @@ import {
 } from "./media/rtpTransceiver";
 import { MediaStream, MediaStreamTrack } from "./media/track";
 import {
-  addSDPHeader,
   GroupDescription,
   MediaDescription,
   SessionDescription,
   SsrcDescription,
+  addSDPHeader,
 } from "./sdp";
 import { RTCCertificate, RTCDtlsTransport } from "./transport/dtls";
 import {
@@ -168,20 +168,18 @@ export class RTCPeerConnection extends EventTarget {
 
       codecParams.payloadType = 96 + i;
       switch (codecParams.name.toLowerCase()) {
-        case "rtx":
-          {
-            codecParams.parameters = `apt=${codecParams.payloadType - 1}`;
-          }
-          break;
-        case "red":
-          {
-            if (codecParams.contentType === "audio") {
-              const redundant = codecParams.payloadType + 1;
-              codecParams.parameters = `${redundant}/${redundant}`;
-              codecParams.payloadType = 63;
-            }
+        case "rtx": {
+          codecParams.parameters = `apt=${codecParams.payloadType - 1}`;
+        }
+        break;
+        case "red": {
+          if (codecParams.contentType === "audio") {
+            const redundant = codecParams.payloadType + 1;
+            codecParams.parameters = `${redundant}/${redundant}`;
+            codecParams.payloadType = 63;
           }
-          break;
+        }
+        break;
       }
     }
 
@@ -214,12 +212,16 @@ export class RTCPeerConnection extends EventTarget {
   }
 
   get localDescription() {
-    if (!this._localDescription) return;
+    if (!this._localDescription) {
+      return undefined;
+    }
     return this._localDescription.toJSON();
   }
 
   get remoteDescription() {
-    if (!this._remoteDescription) return;
+    if (!this._remoteDescription) {
+      return undefined;
+    }
     return this._remoteDescription.toJSON();
   }
 
@@ -241,6 +243,10 @@ export class RTCPeerConnection extends EventTarget {
     );
   }
 
+  getConfiguration() {
+    return this.config;
+  }
+
   async createOffer() {
     await this.ensureCerts();
     const description = this.buildOfferSdp();
@@ -830,7 +836,9 @@ export class RTCPeerConnection extends EventTarget {
 
   get remoteIsBundled() {
     const remoteSdp = this._remoteDescription;
-    if (!remoteSdp) return;
+    if (!remoteSdp) {
+      return undefined;
+    }
     const bundle = remoteSdp.group.find(
       (g) => g.semantic === "BUNDLE" && this.config.bundlePolicy !== "disable",
     );

package/src/sdp.ts

@@ -1,7 +1,7 @@
 import { randomBytes } from "crypto";
+import { isIPv4 } from "net";
 import { Uint64BE } from "int64-buffer";
 import range from "lodash/range";
-import { isIPv4 } from "net";
 
 import {
   DTLS_ROLE_SETUP,
@@ -63,12 +63,13 @@ export class SessionDescription {
       } else if (line.startsWith("a=")) {
         const [attr, value] = parseAttr(line);
         switch (attr) {
-          case "fingerprint":
+          case "fingerprint": {
             const [algorithm, fingerprint] = value?.split(" ") || [];
             session.dtlsFingerprints.push(
               new RTCDtlsFingerprint(algorithm, fingerprint),
             );
-            break;
+          }
+          break;
           case "ice-lite":
             session.iceLite = true;
             break;
@@ -147,7 +148,7 @@ export class SessionDescription {
             case "end-of-candidates":
               currentMedia.iceCandidatesComplete = true;
               break;
-            case "extmap":
+            case "extmap": {
               // eslint-disable-next-line prefer-const
               let [extId, extUri] = value.split(" ");
               if (extId.includes("/")) {
@@ -159,14 +160,16 @@ export class SessionDescription {
                   uri: extUri,
                 }),
               );
-              break;
-            case "fingerprint":
+            }
+            break;
+            case "fingerprint": {
               if (!value) throw new Error();
               const [algorithm, fingerprint] = value.split(" ");
               currentMedia.dtlsParams?.fingerprints.push(
                 new RTCDtlsFingerprint(algorithm, fingerprint),
               );
-              break;
+            }
+            break;
             case "ice-options":
               currentMedia.iceOptions = value;
               break;
@@ -190,11 +193,12 @@ export class SessionDescription {
             case "msid":
               currentMedia.msid = value;
               break;
-            case "rtcp":
+            case "rtcp": {
               const [port, rest] = divide(value, " ");
               currentMedia.rtcpPort = parseInt(port);
               currentMedia.rtcpHost = ipAddressFromSdp(rest);
-              break;
+            }
+            break;
             case "rtcp-mux":
               currentMedia.rtcpMux = true;
               break;
@@ -207,34 +211,34 @@ export class SessionDescription {
             case "inactive":
               currentMedia.direction = attr;
               break;
-            case "rtpmap":
-              {
-                const [formatId, formatDesc] = divide(value, " ");
-                const [type, clock, channel] = formatDesc.split("/");
-                let channels: number | undefined;
-                if (currentMedia.kind === "audio") {
-                  channels = channel ? parseInt(channel) : 1;
-                }
-                const codec = new RTCRtpCodecParameters({
-                  mimeType: currentMedia.kind + "/" + type,
-                  channels,
-                  clockRate: parseInt(clock),
-                  payloadType: parseInt(formatId),
-                });
-                currentMedia.rtp.codecs.push(codec);
+            case "rtpmap": {
+              const [formatId, formatDesc] = divide(value, " ");
+              const [type, clock, channel] = formatDesc.split("/");
+              let channels: number | undefined;
+              if (currentMedia.kind === "audio") {
+                channels = channel ? parseInt(channel) : 1;
               }
-              break;
-            case "sctpmap":
+              const codec = new RTCRtpCodecParameters({
+                mimeType: currentMedia.kind + "/" + type,
+                channels,
+                clockRate: parseInt(clock),
+                payloadType: parseInt(formatId),
+              });
+              currentMedia.rtp.codecs.push(codec);
+            }
+            break;
+            case "sctpmap": {
               if (!value) throw new Error();
               const [formatId, formatDesc] = divide(value, " ");
               currentMedia.sctpMap[parseInt(formatId)] = formatDesc;
               currentMedia.sctpPort = parseInt(formatId);
-              break;
+            }
+            break;
             case "sctp-port":
               if (!value) throw new Error();
               currentMedia.sctpPort = parseInt(value);
               break;
-            case "ssrc":
+            case "ssrc": {
               const [ssrcStr, ssrcDesc] = divide(value, " ");
               const ssrc = parseInt(ssrcStr);
               const [ssrcAttr, ssrcValue] = divide(ssrcDesc, ":");
@@ -246,22 +250,22 @@ export class SessionDescription {
               if (SSRC_INFO_ATTRS.includes(ssrcAttr)) {
                 ssrcInfo[ssrcAttr] = ssrcValue;
               }
-              break;
+            }
+            break;
             case "ssrc-group":
               parseGroup(currentMedia.ssrcGroup, value);
               break;
-            case "rid":
-              {
-                const [rid, direction] = divide(value, " ");
-
-                currentMedia.simulcastParameters.push(
-                  new RTCRtpSimulcastParameters({
-                    rid,
-                    direction: direction as any,
-                  }),
-                );
-              }
-              break;
+            case "rid": {
+              const [rid, direction] = divide(value, " ");
+
+              currentMedia.simulcastParameters.push(
+                new RTCRtpSimulcastParameters({
+                  rid,
+                  direction: direction as any,
+                }),
+              );
+            }
+            break;
           }
         }
       });
@@ -278,11 +282,7 @@ export class SessionDescription {
           for (let i = 0; i < bundle.items.length; i++) {
             if (!bundle.items.includes(i.toString())) continue;
             const check = session.media[i];
-            if (
-              check?.iceParams &&
-              check.iceParams.usernameFragment &&
-              check.iceParams.password
-            ) {
+            if (check.iceParams?.usernameFragment && check.iceParams.password) {
               currentMedia.iceParams = {
                 ...check.iceParams,
               };
@@ -327,7 +327,7 @@ export class SessionDescription {
   }
 
   webrtcTrackId(media: MediaDescription) {
-    if (media.msid && media.msid.includes(" ")) {
+    if (media.msid?.includes(" ")) {
       const bits = media.msid.split(" ");
       for (const group of this.msidSemantic) {
         if (
@@ -532,10 +532,7 @@ export class MediaDescription {
 }
 
 export class GroupDescription {
-  constructor(
-    public semantic: string,
-    public items: string[],
-  ) {}
+  constructor(public semantic: string, public items: string[]) {}
 
   get str() {
     return `${this.semantic} ${this.items.join(" ")}`;
@@ -643,10 +640,7 @@ export function candidateFromSdp(sdp: string) {
 }
 
 export class RTCSessionDescription {
-  constructor(
-    public sdp: string,
-    public type: "offer" | "answer",
-  ) {}
+  constructor(public sdp: string, public type: "offer" | "answer") {}
   static isThis(o: any) {
     if (typeof o?.sdp === "string") return true;
   }
@@ -666,7 +660,7 @@ export function addSDPHeader(
 }
 
 export function codecParametersFromString(str: string) {
-  const parameters = {};
+  const parameters: any = {};
   str.split(";").forEach((param) => {
     if (param.includes("=")) {
       const [k, v] = divide(param, "=");

package/src/transport/dtls.ts

@@ -20,14 +20,14 @@ import { CipherContext } from "../../../dtls/src/context/cipher";
 import { Profile } from "../../../dtls/src/context/srtp";
 import { Connection } from "../../../ice/src";
 import {
-  isMedia,
-  isRtcp,
   RtcpPacket,
   RtcpPacketConverter,
   RtpHeader,
   RtpPacket,
   SrtcpSession,
   SrtpSession,
+  isMedia,
+  isRtcp,
 } from "../../../rtp/src";
 import { keyLength, saltLength } from "../../../rtp/src/srtp/const";
 import { RtpRouter } from "../media/router";
@@ -329,10 +329,7 @@ export type DtlsKeys = {
 };
 
 export class RTCDtlsFingerprint {
-  constructor(
-    public algorithm: string,
-    public value: string,
-  ) {}
+  constructor(public algorithm: string, public value: string) {}
 }
 
 export class RTCDtlsParameters {

package/src/transport/ice.ts

@@ -248,7 +248,7 @@ export class IceCandidate {
 }
 
 export class RTCIceParameters {
-  iceLite: boolean = false;
+  iceLite = false;
   usernameFragment!: string;
   password!: string;