node-datachannel 0.30.0 → 0.32.0

package/src/cpp/media-rtppacketizationconfig-wrapper.h

@@ -0,0 +1,35 @@
+#ifndef MEDIA_RTPPACKETIZATIONCONFIG_WRAPPER_H
+#define MEDIA_RTPPACKETIZATIONCONFIG_WRAPPER_H
+
+#include <memory>
+#include <unordered_set>
+
+#include <napi.h>
+#include <rtc/rtc.hpp>
+
+class RtpPacketizationConfigWrapper : public Napi::ObjectWrap<RtpPacketizationConfigWrapper>
+{
+public:
+  static Napi::FunctionReference constructor;
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  RtpPacketizationConfigWrapper(const Napi::CallbackInfo &info);
+  ~RtpPacketizationConfigWrapper();
+  std::shared_ptr<rtc::RtpPacketizationConfig> getConfigInstance();
+
+  // Functions
+  Napi::Value getPlayoutDelayId(const Napi::CallbackInfo& info);
+  void setPlayoutDelayId(const Napi::CallbackInfo& info, const Napi::Value &val);
+  Napi::Value getPlayoutDelayMin(const Napi::CallbackInfo& info);
+  void setPlayoutDelayMin(const Napi::CallbackInfo& info, const Napi::Value &val);
+  Napi::Value getPlayoutDelayMax(const Napi::CallbackInfo& info);
+  void setPlayoutDelayMax(const Napi::CallbackInfo& info, const Napi::Value &val);
+  Napi::Value getTimestamp(const Napi::CallbackInfo& info);
+  void setTimestamp(const Napi::CallbackInfo& info, const Napi::Value &val);
+  Napi::Value getClockRate(const Napi::CallbackInfo& info);
+  // Callbacks
+
+private:
+  std::shared_ptr<rtc::RtpPacketizationConfig> mConfigPtr = nullptr;
+};
+
+#endif // MEDIA_RTPPACKETIZATIONCONFIG_WRAPPER_H

package/src/cpp/media-rtppacketizer-wrapper.cpp

@@ -0,0 +1,95 @@
+#include "media-rtppacketizer-wrapper.h"
+#include "media-rtppacketizationconfig-wrapper.h"
+#include "media-mediahandler-helper.h"
+
+Napi::FunctionReference RtpPacketizerWrapper::constructor = Napi::FunctionReference();
+
+Napi::Object RtpPacketizerWrapper::Init(Napi::Env env, Napi::Object exports)
+{
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = Napi::ObjectWrap<RtpPacketizerWrapper>::DefineClass(env, "RtpPacketizer",
+    {
+      // Instance Methods
+      InstanceMethod("addToChain", &RtpPacketizerWrapper::addToChain),
+      // Accessors
+      InstanceAccessor("rtpConfig", &RtpPacketizerWrapper::getRtpPacketizationConfig, nullptr),
+    });
+
+  // If this is not the first call, we don't want to reassign the constructor (hot-reload problem)
+  if (constructor.IsEmpty())
+  {
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+  }
+
+  exports.Set("RtpPacketizer", func);
+  return exports;
+}
+
+RtpPacketizerWrapper::RtpPacketizerWrapper(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<RtpPacketizerWrapper>(info)
+{
+  Napi::Env env = info.Env();
+
+  if (!info[0].IsObject())
+  {
+    Napi::TypeError::New(env, "rtpConfig must be a RtpPacketizationConfig instance").ThrowAsJavaScriptException();
+    return;
+  }
+  auto obj = info[0].As<Napi::Object>();
+  if (!obj.InstanceOf(RtpPacketizationConfigWrapper::constructor.Value()))
+  {
+    Napi::TypeError::New(env, "rtpConfig must be a RtpPacketizationConfig instance").ThrowAsJavaScriptException();
+    return;
+  }
+  // store original JS object so we can return it later
+  mRtpConfigObject = Napi::Persistent(obj);
+  mRtpConfigObject.SuppressDestruct();
+  auto rtpConfig = RtpPacketizationConfigWrapper::Unwrap(obj)->getConfigInstance();
+
+  mPacketizerPtr = std::make_unique<rtc::RtpPacketizer>(rtpConfig);
+
+  auto asMediaHandler = new std::shared_ptr<rtc::MediaHandler>(mPacketizerPtr);
+}
+
+RtpPacketizerWrapper::~RtpPacketizerWrapper()
+{
+  mPacketizerPtr.reset();
+  mRtpConfigObject.Reset();
+}
+
+std::shared_ptr<rtc::RtpPacketizer> RtpPacketizerWrapper::getPacketizerInstance() { return mPacketizerPtr; }
+
+void RtpPacketizerWrapper::addToChain(const Napi::CallbackInfo &info)
+{
+  auto env = info.Env();
+  if (info.Length() < 1 || !info[0].IsObject())
+  {
+    Napi::TypeError::New(env, "Expected a MediaHandler instance").ThrowAsJavaScriptException();
+    return;
+  }
+  auto mediaHandler = asMediaHandler(info[0].As<Napi::Object>());
+  if (!mediaHandler)
+  {
+    Napi::TypeError::New(env, "Expected a MediaHandler instance. If this error is unexpected, please report a bug!")
+        .ThrowAsJavaScriptException();
+    return;
+  }
+  mPacketizerPtr->addToChain(mediaHandler);
+}
+
+Napi::Value RtpPacketizerWrapper::getRtpPacketizationConfig(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+  if (!mPacketizerPtr)
+  {
+    Napi::Error::New(env, "getRtpPacketizationConfig() called on destroyed packetizer").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (mRtpConfigObject.IsEmpty())
+    return env.Null();
+
+  return mRtpConfigObject.Value();
+}

package/src/cpp/media-rtppacketizer-wrapper.h

@@ -0,0 +1,30 @@
+#ifndef MEDIA_RTPPACKETIZER_WRAPPER_H
+#define MEDIA_RTPPACKETIZER_WRAPPER_H
+
+#include <memory>
+#include <unordered_set>
+
+#include <napi.h>
+#include <rtc/rtc.hpp>
+
+class RtpPacketizerWrapper : public Napi::ObjectWrap<RtpPacketizerWrapper>
+{
+public:
+  static Napi::FunctionReference constructor;
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  RtpPacketizerWrapper(const Napi::CallbackInfo &info);
+  ~RtpPacketizerWrapper();
+  std::shared_ptr<rtc::RtpPacketizer> getPacketizerInstance();
+
+  // Functions
+  void addToChain(const Napi::CallbackInfo &info);
+  Napi::Value getRtpPacketizationConfig(const Napi::CallbackInfo &info);
+
+  // Callbacks
+
+private:
+  std::shared_ptr<rtc::RtpPacketizer> mPacketizerPtr = nullptr;
+  Napi::ObjectReference mRtpConfigObject;
+};
+
+#endif // MEDIA_RTPPACKETIZER_WRAPPER_H

package/src/cpp/media-track-wrapper.cpp

@@ -1,6 +1,6 @@
 #include "media-track-wrapper.h"
 #include "media-direction.h"
-#include "media-rtcpreceivingsession-wrapper.h"
+#include "media-mediahandler-helper.h"
 
 #include "plog/Log.h"
 
@@ -292,9 +292,14 @@ void TrackWrapper::setMediaHandler(const Napi::CallbackInfo &info)
     return;
   }
 
-  RtcpReceivingSessionWrapper *handler =
-      Napi::ObjectWrap<RtcpReceivingSessionWrapper>::Unwrap(info[0].As<Napi::Object>());
-  mTrackPtr->setMediaHandler(handler->getSessionInstance());
+  std::shared_ptr<rtc::MediaHandler> handler = asMediaHandler(info[0].As<Napi::Object>());
+  if (!handler)
+  {
+    Napi::TypeError::New(env, "MediaHandler class instance expected. If this error is unexpected, please report a bug!")
+      .ThrowAsJavaScriptException();
+    return;
+  }
+  mTrackPtr->setMediaHandler(handler);
 }
 
 void TrackWrapper::onOpen(const Napi::CallbackInfo &info)

package/src/cpp/media-video-wrapper.cpp

@@ -12,10 +12,12 @@ Napi::Object VideoWrapper::Init(Napi::Env env, Napi::Object exports)
       Napi::ObjectWrap<VideoWrapper>::DefineClass(env, "Video",
                                                   {
                                                       InstanceValue("media-type-video", Napi::Boolean::New(env, true)),
-                                                      InstanceMethod("addH264Codec", &VideoWrapper::addH264Codec),
                                                       InstanceMethod("addVideoCodec", &VideoWrapper::addVideoCodec),
+                                                      InstanceMethod("addH264Codec", &VideoWrapper::addH264Codec),
+                                                      InstanceMethod("addH265Codec", &VideoWrapper::addH265Codec),
                                                       InstanceMethod("addVP8Codec", &VideoWrapper::addVP8Codec),
                                                       InstanceMethod("addVP9Codec", &VideoWrapper::addVP9Codec),
+                                                      InstanceMethod("addAV1Codec", &VideoWrapper::addAV1Codec),
                                                       InstanceMethod("direction", &VideoWrapper::direction),
                                                       InstanceMethod("generateSdp", &VideoWrapper::generateSdp),
                                                       InstanceMethod("mid", &VideoWrapper::mid),
@@ -147,6 +149,22 @@ void VideoWrapper::addH264Codec(const Napi::CallbackInfo &info)
   mVideoPtr->addH264Codec(payloadType, profile);
 }
 
+void VideoWrapper::addH265Codec(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  if (length < 1 || !info[0].IsNumber())
+  {
+    Napi::TypeError::New(env, "We expect (Number) as param").ThrowAsJavaScriptException();
+    return;
+  }
+
+  int payloadType = info[0].As<Napi::Number>().ToNumber();
+
+  mVideoPtr->addH265Codec(payloadType);
+}
+
 void VideoWrapper::addVP8Codec(const Napi::CallbackInfo &info)
 {
   Napi::Env env = info.Env();
@@ -179,6 +197,23 @@ void VideoWrapper::addVP9Codec(const Napi::CallbackInfo &info)
   mVideoPtr->addVP9Codec(payloadType);
 }
 
+void VideoWrapper::addAV1Codec(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  if (length < 1 || !info[0].IsNumber())
+  {
+    Napi::TypeError::New(env, "We expect (Number) as param").ThrowAsJavaScriptException();
+    return;
+  }
+
+  int payloadType = info[0].As<Napi::Number>().ToNumber();
+
+  mVideoPtr->addAV1Codec(payloadType);
+}
+
+
 Napi::Value VideoWrapper::direction(const Napi::CallbackInfo &info)
 {
   Napi::Env env = info.Env();

package/src/cpp/media-video-wrapper.h

@@ -19,8 +19,10 @@ public:
   // Functions
   void addVideoCodec(const Napi::CallbackInfo &info);
   void addH264Codec(const Napi::CallbackInfo &info);
+  void addH265Codec(const Napi::CallbackInfo &info);
   void addVP8Codec(const Napi::CallbackInfo &info);
   void addVP9Codec(const Napi::CallbackInfo &info);
+  void addAV1Codec(const Napi::CallbackInfo &info);
 
   // class Entry
   Napi::Value direction(const Napi::CallbackInfo &info);

package/src/lib/index.ts

@@ -7,6 +7,8 @@ import {
   DescriptionType,
   Direction,
   LogLevel,
+  NalUnitSeparator,
+  ObuPacketization,
   RtcConfig,
   RTCIceConnectionState,
   RTCIceGatheringState,
@@ -63,8 +65,10 @@ export const Audio: {
 export interface Video {
   addVideoCodec(payloadType: number, codec: string, profile?: string): void;
   addH264Codec(payloadType: number, profile?: string): void;
+  addH265Codec(payloadType: number): void;
   addVP8Codec(payloadType: number): void;
   addVP9Codec(payloadType: number): void;
+  addAV1Codec(payloadType: number): void;
   direction(): Direction;
   generateSdp(eol: string, addr: string, port: number): string;
   mid(): string;
@@ -102,7 +106,7 @@ export interface Track {
   requestBitrate(bitRate: number): boolean;
   setBufferedAmountLowThreshold(newSize: number): void;
   requestKeyframe(): boolean;
-  setMediaHandler(handler: RtcpReceivingSession): void;
+  setMediaHandler(handler: MediaHandler): void;
   onOpen(cb: () => void): void;
   onClosed(cb: () => void): void;
   onError(cb: (err: string) => void): void;
@@ -182,12 +186,74 @@ export const IceUdpMuxListener: {
   new (port: number, address?: string): IceUdpMuxListener;
 } = nodeDataChannel.IceUdpMuxListener;
 
-export interface RtcpReceivingSession {}
+export interface RtpPacketizationConfig {
+  playoutDelayId: number,
+  playoutDelayMin: number,
+  playoutDelayMax: number,
+  timestamp: number,
+  get clockRate(): number
+}
+
+export const RtpPacketizationConfig: {
+  new(ssrc: number, cname: string, payloadType: number, clockRate: number, videoOrientationId?: number): RtpPacketizationConfig
+} = nodeDataChannel.RtpPacketizationConfig
+
+export interface MediaHandler {
+  addToChain(handler: MediaHandler): void
+}
+
+export interface PacingHandler extends MediaHandler {}
+
+export const PacingHandler: {
+  new (bitsPerSecond: number, sendInterval: number): PacingHandler;
+} = nodeDataChannel.PacingHandler;
+
+export interface RtcpReceivingSession extends MediaHandler {}
 
 export const RtcpReceivingSession: {
   new (): RtcpReceivingSession;
 } = nodeDataChannel.RtcpReceivingSession;
 
+export interface RtcpNackResponder extends MediaHandler {}
+
+export const RtcpNackResponder: {
+  new (maxSize?: number): RtcpNackResponder
+} = nodeDataChannel.RtcpNackResponder;
+
+export interface RtcpSrReporter extends MediaHandler {
+  get rtpConfig(): RtpPacketizationConfig
+}
+
+export const RtcpSrReporter: {
+  new (rtpConfig: RtpPacketizationConfig): RtcpSrReporter
+} = nodeDataChannel.RtcpSrReporter;
+
+export interface RtpPacketizer extends MediaHandler {
+  get rtpConfig(): RtpPacketizationConfig
+}
+
+export const RtpPacketizer: {
+  new (rtpConfig: RtpPacketizationConfig): RtpPacketizer
+} = nodeDataChannel.RtpPacketizer;
+
+export interface H264RtpPacketizer extends RtpPacketizer {}
+
+export const H264RtpPacketizer: {
+  new (separator: NalUnitSeparator, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number): H264RtpPacketizer
+} = nodeDataChannel.H264RtpPacketizer
+
+export interface H265RtpPacketizer extends RtpPacketizer {}
+
+export const H265RtpPacketizer: {
+  new (separator: NalUnitSeparator, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number): H265RtpPacketizer
+} = nodeDataChannel.H265RtpPacketizer
+
+export interface AV1RtpPacketizer extends RtpPacketizer {}
+
+export const AV1RtpPacketizer: {
+  new (packetization: ObuPacketization, rtpConfig: RtpPacketizationConfig, maxFragmentSize?: number): AV1RtpPacketizer
+} = nodeDataChannel.AV1RtpPacketizer
+
 export { WebSocketServer } from './websocket-server';
 export { WebSocket } from './websocket';
 
@@ -199,7 +265,15 @@ export default {
   preload,
   setSctpSettings,
   getLibraryVersion,
+  PacingHandler,
   RtcpReceivingSession,
+  RtcpNackResponder,
+  RtcpSrReporter,
+  RtpPacketizationConfig,
+  RtpPacketizer,
+  H264RtpPacketizer,
+  H265RtpPacketizer,
+  AV1RtpPacketizer,
   Track,
   Video,
   Audio,

package/src/lib/types.ts

@@ -160,3 +160,9 @@ export interface IceUdpMuxRequest {
   host: string;
   port: number;
 }
+
+// Same as rtc::NalUnit::Separator
+export type NalUnitSeparator = 'Length' | 'ShortStartSequence' | 'LongStartSequence' | 'StartSequence';
+
+// Same as rtc::AV1RtpPacketizer::Packetization
+export type ObuPacketization = 'Obu' | 'TemporalUnit';

package/src/polyfill/RTCPeerConnection.ts

@@ -36,7 +36,7 @@ export default class RTCPeerConnection extends EventTarget implements globalThis
   // events
   onconnectionstatechange: globalThis.RTCPeerConnection['onconnectionstatechange'] = null;
   // For ondatachannel we need to define type manually
-  ondatachannel: ((this: globalThis.RTCPeerConnection, ev: globalThis.RTCDataChannelEvent) => any) | null;
+  ondatachannel: ((this: globalThis.RTCPeerConnection, ev: RTCDataChannelEvent) => any) | null;
   onicecandidate: globalThis.RTCPeerConnection['onicecandidate'] = null;
   onicecandidateerror: globalThis.RTCPeerConnection['onicecandidateerror'] = null;
   oniceconnectionstatechange: globalThis.RTCPeerConnection['oniceconnectionstatechange'] = null;