werift 0.13.5 → 0.14.1-debug

package/src/media/rtpSender.ts

@@ -16,6 +16,7 @@ import {
   GenericNack,
   PictureLossIndication,
   ReceiverEstimatedMaxBitrate,
+  Red,
   RtcpPacket,
   RtcpPayloadSpecificFeedback,
   RtcpRrPacket,
@@ -29,6 +30,7 @@ import {
   SourceDescriptionItem,
   TransportWideCC,
 } from "../../../rtp/src";
+import { codecParametersFromString } from "..";
 import { RTCDtlsTransport } from "../transport/dtls";
 import { Kind } from "../types/domain";
 import { compactNtp, milliTime, ntpTime } from "../utils";
@@ -68,6 +70,8 @@ export class RTCRtpSender {
   private repairedRtpStreamId?: string;
   private rtxPayloadType?: number;
   private rtxSequenceNumber = random16();
+  redRedundantPayloadType?: number;
+  redDistance = 2;
   private headerExtensions: RTCRtpHeaderExtensionParameters[] = [];
   private disposeTrack?: () => void;
 
@@ -87,7 +91,7 @@ export class RTCRtpSender {
   private timestampOffset = 0;
   private seqOffset = 0;
   private rtpCache: RtpPacket[] = [];
-  private codec?: RTCRtpCodecParameters;
+  codec?: RTCRtpCodecParameters;
 
   track?: MediaStreamTrack;
   stopped = false;
@@ -118,20 +122,25 @@ export class RTCRtpSender {
     this.rtpStreamId = params.rtpStreamId;
     this.repairedRtpStreamId = params.repairedRtpStreamId;
 
-    for (const codec of params.codecs) {
+    this.codec = params.codecs[0];
+    if (this.track) {
+      this.track.codec = this.codec;
+    }
+
+    params.codecs.forEach((codec) => {
+      const codecParams = codecParametersFromString(codec.parameters ?? "");
       if (
         codec.name.toLowerCase() === "rtx" &&
-        codec.parameters["apt"] === params.codecs[0].payloadType
+        codecParams["apt"] === this.codec?.payloadType
       ) {
         this.rtxPayloadType = codec.payloadType;
-        break;
       }
-    }
-
-    this.codec = params.codecs[0];
-    if (this.track) {
-      this.track.codec = this.codec;
-    }
+      if (codec.name.toLowerCase() === "red") {
+        this.redRedundantPayloadType = Number(
+          (codec.parameters ?? "").split("/")[0]
+        );
+      }
+    });
   }
 
   registerTrack(track: MediaStreamTrack) {
@@ -242,9 +251,7 @@ export class RTCRtpSender {
       this.seqOffset = uint16Add(this.sequenceNumber, -sequenceNumber);
     }
     if (this.timestamp != undefined) {
-      this.timestampOffset = Number(
-        uint32Add(BigInt(this.timestamp), BigInt(-timestamp))
-      );
+      this.timestampOffset = uint32Add(this.timestamp, -timestamp);
     }
     this.rtpCache = [];
     log("replaceRTP", this.sequenceNumber, sequenceNumber, this.seqOffset);
@@ -260,9 +267,7 @@ export class RTCRtpSender {
     const header = rtp.header;
     header.ssrc = this.ssrc;
     header.payloadType = this.codec.payloadType;
-    header.timestamp = Number(
-      uint32Add(BigInt(header.timestamp), BigInt(this.timestampOffset))
-    );
+    header.timestamp = uint32Add(header.timestamp, this.timestampOffset);
     header.sequenceNumber = uint16Add(header.sequenceNumber, this.seqOffset);
     this.timestamp = header.timestamp;
     this.sequenceNumber = header.sequenceNumber;
@@ -312,14 +317,34 @@ export class RTCRtpSender {
     this.ntpTimestamp = ntpTime();
     this.rtpTimestamp = rtp.header.timestamp;
     this.octetCount += rtp.payload.length;
-    this.packetCount = Number(uint32Add(BigInt(this.packetCount), 1n));
+    this.packetCount = uint32Add(this.packetCount, 1);
 
     rtp.header = header;
 
     this.rtpCache.push(rtp);
     this.rtpCache = this.rtpCache.slice(-RTP_HISTORY_SIZE);
 
-    const size = this.dtlsTransport.sendRtp(rtp.payload, header);
+    let rtpPayload = rtp.payload;
+
+    if (this.redRedundantPayloadType) {
+      const redundantPackets = [...Array(this.redDistance).keys()]
+        .map((i) => {
+          return this.rtpCache.find(
+            (c) =>
+              c.header.sequenceNumber ===
+              header.sequenceNumber - (this.redDistance - i)
+          );
+        })
+        .filter((p): p is NonNullable<typeof p> => typeof p !== "undefined");
+      const red = buildRedPacket(
+        redundantPackets,
+        this.redRedundantPayloadType,
+        rtp
+      );
+      rtpPayload = red.serialize();
+    }
+
+    const size = this.dtlsTransport.sendRtp(rtpPayload, header);
 
     this.runRtcp();
     const sentInfo: SentInfo = {
@@ -437,3 +462,27 @@ export function wrapRtx(
   );
   return rtx;
 }
+
+export function buildRedPacket(
+  redundantPackets: RtpPacket[],
+  blockPT: number,
+  presentPacket: RtpPacket
+) {
+  const red = new Red();
+  redundantPackets.forEach((redundant) => {
+    red.blocks.push({
+      block: redundant.payload,
+      blockPT,
+      timestampOffset: uint32Add(
+        presentPacket.header.timestamp,
+        -redundant.header.timestamp
+      ),
+    });
+  });
+
+  red.blocks.push({
+    block: presentPacket.payload,
+    blockPT,
+  });
+  return red;
+}

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

@@ -1,3 +1,5 @@
+import * as fs from "fs/promises";
+
 import { SupportedCodec } from "../../../../../rtp/src/container/webm";
 import {
   JitterBuffer,
@@ -12,6 +14,7 @@ export class WebmFactory extends MediaWriter {
 
   start(tracks: MediaStreamTrack[]) {
     this.webm = new WebmOutput(
+      fs,
       "./test.webm",
       tracks.map((track, i) => {
         const trackNumber = i + 1;

package/src/peerConnection.ts

@@ -4,6 +4,7 @@ import Event from "rx.mini";
 import * as uuid from "uuid";
 
 import { Profile } from "../../dtls/src/context/srtp";
+import { codecParametersFromString, DtlsKeys } from ".";
 import {
   DISCARD_HOST,
   DISCARD_PORT,
@@ -96,7 +97,7 @@ export class RTCPeerConnection extends EventTarget {
 
   private readonly router = new RtpRouter();
   private readonly certificates: RTCCertificate[] = [];
-  private sctpRemotePort?: number;
+  sctpRemotePort?: number;
   private seenMid = new Set<string>();
   private currentLocalDescription?: SessionDescription;
   private currentRemoteDescription?: SessionDescription;
@@ -111,6 +112,7 @@ export class RTCPeerConnection extends EventTarget {
     iceServers,
     iceTransportPolicy,
     icePortRange,
+    dtls,
   }: Partial<PeerConfig> = {}) {
     super();
 
@@ -126,15 +128,27 @@ export class RTCPeerConnection extends EventTarget {
     if (codecs?.audio) this.configuration.codecs.audio = codecs.audio;
     if (codecs?.video) this.configuration.codecs.video = codecs.video;
 
-    [
+    for (const [i, codecParams] of enumerate([
       ...(this.configuration.codecs.audio || []),
       ...(this.configuration.codecs.video || []),
-    ].forEach((v, i) => {
-      v.payloadType = 96 + i;
-      if (v.name.toLowerCase() === "rtx") {
-        v.parameters = { apt: v.payloadType - 1 };
+    ])) {
+      codecParams.payloadType = 96 + i;
+      switch (codecParams.name.toLowerCase()) {
+        case "rtx":
+          {
+            codecParams.parameters = `apt=${codecParams.payloadType - 1}`;
+          }
+          break;
+        case "red":
+          {
+            const redundant = codecParams.payloadType + 1;
+            codecParams.parameters = `${redundant}/${redundant}`;
+            codecParams.payloadType = 63;
+          }
+          break;
       }
-    });
+    }
+
     if (headerExtensions?.audio)
       this.configuration.headerExtensions.audio = headerExtensions.audio;
     if (headerExtensions?.video)
@@ -146,6 +160,15 @@ export class RTCPeerConnection extends EventTarget {
       v.id = 1 + i;
     });
 
+    if (dtls) {
+      const { keys } = dtls;
+      if (keys) {
+        this.certificates.push(
+          new RTCCertificate(keys.keyPem, keys.certPem, keys.signatureHash)
+        );
+      }
+    }
+
     this.iceConnectionStateChange.subscribe((state) => {
       switch (state) {
         case "disconnected":
@@ -576,7 +599,8 @@ export class RTCPeerConnection extends EventTarget {
         transceiver.codecs.reduce(
           (acc: { [pt: number]: RTCRtpCodingParameters }, codec) => {
             if (codec.name.toLowerCase() === "rtx") {
-              const apt = acc[codec.parameters["apt"]];
+              const params = codecParametersFromString(codec.parameters ?? "");
+              const apt = acc[params["apt"]];
               if (apt && media.ssrc.length === 2) {
                 apt.rtx = new RTCRtpRtxParameters({ ssrc: media.ssrc[1].ssrc });
               }
@@ -639,7 +663,10 @@ export class RTCPeerConnection extends EventTarget {
           if (!existCodec) return false;
 
           if (existCodec?.name.toLowerCase() === "rtx") {
-            const pt = existCodec.parameters["apt"];
+            const params = codecParametersFromString(
+              existCodec.parameters ?? ""
+            );
+            const pt = params["apt"];
             const origin = remoteMedia.rtp.codecs.find(
               (c) => c.payloadType === pt
             );
@@ -879,7 +906,7 @@ export class RTCPeerConnection extends EventTarget {
     return this.transceivers;
   }
 
-  getSenders() {
+  getSenders(): RTCRtpSender[] {
     return this.getTransceivers().map((t) => t.sender);
   }
 
@@ -888,7 +915,11 @@ export class RTCPeerConnection extends EventTarget {
   }
 
   // todo fix
-  addTrack(track: MediaStreamTrack, ms?: MediaStream) {
+  addTrack(
+    track: MediaStreamTrack,
+    /**todo impl */
+    ms?: MediaStream
+  ) {
     if (this.isClosed) throw new Error("is closed");
     if (this.getSenders().find((sender) => sender.track?.uuid === track.uuid)) {
       throw new Error("track exist");
@@ -1185,6 +1216,9 @@ export interface PeerConfig {
   iceServers: RTCIceServer[];
   /**Minimum port and Maximum port must not be the same value */
   icePortRange: [number, number] | undefined;
+  dtls: Partial<{
+    keys: DtlsKeys;
+  }>;
 }
 
 export const findCodecByMimeType = (
@@ -1235,6 +1269,7 @@ export const defaultPeerConfig: PeerConfig = {
   iceTransportPolicy: "all",
   iceServers: [{ urls: "stun:stun.l.google.com:19302" }],
   icePortRange: undefined,
+  dtls: {},
 };
 
 export interface RTCTrackEvent {

package/src/sdp.ts

@@ -223,7 +223,8 @@ export class SessionDescription {
             case "sctpmap":
               if (!value) throw new Error();
               const [formatId, formatDesc] = divide(value, " ");
-              (currentMedia as any)[attr][parseInt(formatId)] = formatDesc;
+              currentMedia.sctpMap[parseInt(formatId)] = formatDesc;
+              currentMedia.sctpPort = parseInt(formatId);
               break;
             case "sctp-port":
               if (!value) throw new Error();
@@ -274,7 +275,7 @@ export class SessionDescription {
           if (attr === "fmtp") {
             const [formatId, formatDesc] = divide(value, " ");
             const codec = findCodec(Number(formatId))!;
-            codec.parameters = parametersFromSdp(formatDesc);
+            codec.parameters = formatDesc;
           } else if (attr === "rtcp-fb") {
             const [payloadType, feedbackType, feedbackParam] = value.split(" ");
             currentMedia.rtp.codecs.forEach((codec) => {
@@ -453,9 +454,8 @@ export class MediaDescription {
         lines.push(`a=rtcp-fb:${codec.payloadType} ${value}`);
       });
 
-      const params = parametersToSDP(codec.parameters);
-      if (params) {
-        lines.push(`a=fmtp:${codec.payloadType} ${params}`);
+      if (codec.parameters) {
+        lines.push(`a=fmtp:${codec.payloadType} ${codec.parameters}`);
       }
     });
 
@@ -634,9 +634,9 @@ export function addSDPHeader(
   description.type = type;
 }
 
-function parametersFromSdp(sdp: string) {
+export function codecParametersFromString(str: string) {
   const parameters = {};
-  sdp.split(";").forEach((param) => {
+  str.split(";").forEach((param) => {
     if (param.includes("=")) {
       const [k, v] = divide(param, "=");
       if (FMTP_INT_PARAMETERS.includes(k)) {
@@ -651,7 +651,9 @@ function parametersFromSdp(sdp: string) {
   return parameters;
 }
 
-function parametersToSDP(parameters: { [key: string]: string }) {
+export function codecParametersToString(parameters: {
+  [key: string]: string | number;
+}) {
   const params = Object.entries(parameters).map(([k, v]) => {
     if (v) return `${k}=${v}`;
     else return k;

package/src/transport/dtls.ts

@@ -261,6 +261,12 @@ export class RTCCertificate {
   }
 }
 
+export type DtlsKeys = {
+  certPem: string;
+  keyPem: string;
+  signatureHash: SignatureHash;
+};
+
 export class RTCDtlsFingerprint {
   constructor(public algorithm: string, public value: string) {}
 }

package/src/utils.ts

@@ -11,6 +11,7 @@ import {
   uint16Add,
   uint32Add,
 } from "../../common/src";
+import { CipherContext } from "../../dtls/src/context/cipher";
 import { Address } from "../../ice/src";
 import { RtpHeader, RtpPacket } from "../../rtp/src";
 import { Direction, Directions } from "./media/rtpTransceiver";
@@ -114,7 +115,7 @@ export class RtpBuilder {
 
   create(payload: Buffer) {
     this.sequenceNumber = uint16Add(this.sequenceNumber, 1);
-    this.timestamp = uint32Add(this.timestamp, BigInt(960));
+    this.timestamp = uint32Add(this.timestamp, 960);
 
     const header = new RtpHeader({
       sequenceNumber: this.sequenceNumber,
@@ -128,3 +129,11 @@ export class RtpBuilder {
     return rtp;
   }
 }
+
+/**
+ *
+ * @param signatureHash
+ * @param namedCurveAlgorithm necessary when use ecdsa
+ */
+export const createSelfSignedCertificate =
+  CipherContext.createSelfSignedCertificateWithKey;