node-datachannel 0.29.0 → 0.31.0

package/src/cpp/data-channel-wrapper.h

@@ -1,9 +1,7 @@
 #ifndef DATA_CHANNEL_WRAPPER_H
 #define DATA_CHANNEL_WRAPPER_H
 
-#include <iostream>
 #include <string>
-#include <variant>
 #include <memory>
 #include <unordered_set>
 

package/src/cpp/ice-udp-mux-listener-wrapper.cpp

@@ -3,104 +3,106 @@
 #include "plog/Log.h"
 
 #include <cctype>
-#include <sstream>
 
 Napi::FunctionReference IceUdpMuxListenerWrapper::constructor = Napi::FunctionReference();
 std::unordered_set<IceUdpMuxListenerWrapper *> IceUdpMuxListenerWrapper::instances;
 
 void IceUdpMuxListenerWrapper::StopAll()
 {
-    PLOG_DEBUG << "IceUdpMuxListenerWrapper StopAll() called";
-    auto copy(instances);
-    for (auto inst : copy)
-        inst->doCleanup();
+  PLOG_DEBUG << "IceUdpMuxListenerWrapper StopAll() called";
+  auto copy(instances);
+  for (auto inst : copy)
+    inst->doCleanup();
 }
 
 Napi::Object IceUdpMuxListenerWrapper::Init(Napi::Env env, Napi::Object exports)
 {
-    Napi::HandleScope scope(env);
-
-    Napi::Function func = DefineClass(
-        env,
-        "IceUdpMuxListener",
-        {
-            InstanceMethod("stop", &IceUdpMuxListenerWrapper::stop),
-            InstanceMethod("onUnhandledStunRequest", &IceUdpMuxListenerWrapper::onUnhandledStunRequest),
-            InstanceMethod("port", &IceUdpMuxListenerWrapper::port),
-            InstanceMethod("address", &IceUdpMuxListenerWrapper::address)
-        });
-
-    // 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("IceUdpMuxListener", func);
-    return exports;
+  Napi::HandleScope scope(env);
+
+  Napi::Function func =
+      DefineClass(env, "IceUdpMuxListener",
+                  {InstanceMethod("stop", &IceUdpMuxListenerWrapper::stop),
+                   InstanceMethod("onUnhandledStunRequest", &IceUdpMuxListenerWrapper::onUnhandledStunRequest),
+                   InstanceMethod("port", &IceUdpMuxListenerWrapper::port),
+                   InstanceMethod("address", &IceUdpMuxListenerWrapper::address)});
+
+  // 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("IceUdpMuxListener", func);
+  return exports;
 }
 
-IceUdpMuxListenerWrapper::IceUdpMuxListenerWrapper(const Napi::CallbackInfo &info) : Napi::ObjectWrap<IceUdpMuxListenerWrapper>(info)
+IceUdpMuxListenerWrapper::IceUdpMuxListenerWrapper(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<IceUdpMuxListenerWrapper>(info)
 {
-    PLOG_DEBUG << "IceUdpMuxListenerWrapper Constructor called";
-    Napi::Env env = info.Env();
-    int length = info.Length();
-
-    // We expect (Number, String?) as param
-    if (length > 0 && info[0].IsNumber()) {
-      // Port
-      mPort = info[0].As<Napi::Number>().ToNumber().Uint32Value();
-    } else {
-      Napi::TypeError::New(env, "Port (Number) and optional Address (String) expected").ThrowAsJavaScriptException();
-      return;
-    }
-
-    if (length > 1 && info[1].IsString()) {
-      // Address
-      mAddress = info[1].As<Napi::String>().ToString();
-    }
-
-    iceUdpMuxListenerPtr = std::make_unique<rtc::IceUdpMuxListener>(mPort, mAddress);
-    instances.insert(this);
+  PLOG_DEBUG << "IceUdpMuxListenerWrapper Constructor called";
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  // We expect (Number, String?) as param
+  if (length > 0 && info[0].IsNumber())
+  {
+    // Port
+    mPort = info[0].As<Napi::Number>().ToNumber().Uint32Value();
+  }
+  else
+  {
+    Napi::TypeError::New(env, "Port (Number) and optional Address (String) expected").ThrowAsJavaScriptException();
+    return;
+  }
+
+  if (length > 1 && info[1].IsString())
+  {
+    // Address
+    mAddress = info[1].As<Napi::String>().ToString();
+  }
+
+  iceUdpMuxListenerPtr = std::make_unique<rtc::IceUdpMuxListener>(mPort, mAddress);
+  instances.insert(this);
 }
 
 IceUdpMuxListenerWrapper::~IceUdpMuxListenerWrapper()
 {
-    PLOG_DEBUG << "IceUdpMuxListenerWrapper Destructor called";
-    doCleanup();
+  PLOG_DEBUG << "IceUdpMuxListenerWrapper Destructor called";
+  doCleanup();
 }
 
 void IceUdpMuxListenerWrapper::doCleanup()
 {
-    PLOG_DEBUG << "IceUdpMuxListenerWrapper::doCleanup() called";
+  PLOG_DEBUG << "IceUdpMuxListenerWrapper::doCleanup() called";
 
-    if (iceUdpMuxListenerPtr)
-    {
-      iceUdpMuxListenerPtr->stop();
-      iceUdpMuxListenerPtr.reset();
-    }
+  if (iceUdpMuxListenerPtr)
+  {
+    iceUdpMuxListenerPtr->stop();
+    iceUdpMuxListenerPtr.reset();
+  }
 
-    mOnUnhandledStunRequestCallback.reset();
-    instances.erase(this);
+  mOnUnhandledStunRequestCallback.reset();
+  instances.erase(this);
 }
 
 Napi::Value IceUdpMuxListenerWrapper::port(const Napi::CallbackInfo &info)
 {
-    Napi::Env env = info.Env();
+  Napi::Env env = info.Env();
 
-    return Napi::Number::New(env, mPort);
+  return Napi::Number::New(env, mPort);
 }
 
 Napi::Value IceUdpMuxListenerWrapper::address(const Napi::CallbackInfo &info)
 {
-    Napi::Env env = info.Env();
+  Napi::Env env = info.Env();
 
-    if (!mAddress.has_value()) {
-      return env.Undefined();
-    }
+  if (!mAddress.has_value())
+  {
+    return env.Undefined();
+  }
 
-    return Napi::String::New(env, mAddress.value());
+  return Napi::String::New(env, mAddress.value());
 }
 
 void IceUdpMuxListenerWrapper::stop(const Napi::CallbackInfo &info)
@@ -111,40 +113,45 @@ void IceUdpMuxListenerWrapper::stop(const Napi::CallbackInfo &info)
 
 void IceUdpMuxListenerWrapper::onUnhandledStunRequest(const Napi::CallbackInfo &info)
 {
-    PLOG_DEBUG << "IceUdpMuxListenerWrapper::onUnhandledStunRequest() called";
-    Napi::Env env = info.Env();
-    int length = info.Length();
-
-    if (!iceUdpMuxListenerPtr)
-    {
-        Napi::Error::New(env, "IceUdpMuxListenerWrapper::onUnhandledStunRequest() called on destroyed IceUdpMuxListener").ThrowAsJavaScriptException();
-        return;
-    }
-
-    if (length < 1 || !info[0].IsFunction())
+  PLOG_DEBUG << "IceUdpMuxListenerWrapper::onUnhandledStunRequest() called";
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  if (!iceUdpMuxListenerPtr)
+  {
+    Napi::Error::New(env, "IceUdpMuxListenerWrapper::onUnhandledStunRequest() called on destroyed IceUdpMuxListener")
+        .ThrowAsJavaScriptException();
+    return;
+  }
+
+  if (length < 1 || !info[0].IsFunction())
+  {
+    Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
+    return;
+  }
+
+  // Callback
+  mOnUnhandledStunRequestCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
+
+  iceUdpMuxListenerPtr->OnUnhandledStunRequest(
+      [&](rtc::IceUdpMuxRequest request)
+      {
+    PLOG_DEBUG << "IceUdpMuxListenerWrapper::onUnhandledStunRequest() IceUdpMuxCallback call(1)";
+
+    if (mOnUnhandledStunRequestCallback)
     {
-        Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
-        return;
+      mOnUnhandledStunRequestCallback->call(
+          [request = std::move(request)](Napi::Env env, std::vector<napi_value> &args)
+          {
+        Napi::Object reqObj = Napi::Object::New(env);
+        reqObj.Set("ufrag", request.remoteUfrag.c_str());
+        reqObj.Set("host", request.remoteAddress.c_str());
+        reqObj.Set("port", request.remotePort);
+
+        args = {reqObj};
+      });
     }
 
-    // Callback
-    mOnUnhandledStunRequestCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
-
-    iceUdpMuxListenerPtr->OnUnhandledStunRequest([&](rtc::IceUdpMuxRequest request)
-    {
-        PLOG_DEBUG << "IceUdpMuxListenerWrapper::onUnhandledStunRequest() IceUdpMuxCallback call(1)";
-
-        if (mOnUnhandledStunRequestCallback) {
-            mOnUnhandledStunRequestCallback->call([request = std::move(request)](Napi::Env env, std::vector<napi_value> &args) {
-                Napi::Object reqObj = Napi::Object::New(env);
-                reqObj.Set("ufrag", request.remoteUfrag.c_str());
-                reqObj.Set("host", request.remoteAddress.c_str());
-                reqObj.Set("port", request.remotePort);
-
-                args = {reqObj};
-            });
-        }
-
-        PLOG_DEBUG << "IceUdpMuxListenerWrapper::onUnhandledStunRequest() IceUdpMuxCallback call(2)";
-    });
+    PLOG_DEBUG << "IceUdpMuxListenerWrapper::onUnhandledStunRequest() IceUdpMuxCallback call(2)";
+  });
 }

package/src/cpp/main.cpp

@@ -5,7 +5,14 @@
 #include "ice-udp-mux-listener-wrapper.h"
 
 #if RTC_ENABLE_MEDIA == 1
+#include "media-av1rtppacketizer-wrapper.h"
+#include "media-h264rtppacketizer-wrapper.h"
+#include "media-h265rtppacketizer-wrapper.h"
+#include "media-rtcpnackresponder-wrapper.h"
 #include "media-rtcpreceivingsession-wrapper.h"
+#include "media-rtcpsrreporter-wrapper.h"
+#include "media-rtppacketizationconfig-wrapper.h"
+#include "media-rtppacketizer-wrapper.h"
 #include "media-track-wrapper.h"
 #include "media-video-wrapper.h"
 #include "media-audio-wrapper.h"
@@ -18,25 +25,32 @@
 
 Napi::Object InitAll(Napi::Env env, Napi::Object exports)
 {
-    RtcWrapper::Init(env, exports);
+  RtcWrapper::Init(env, exports);
 
 #if RTC_ENABLE_MEDIA == 1
-    RtcpReceivingSessionWrapper::Init(env, exports);
-    TrackWrapper::Init(env, exports);
-    VideoWrapper::Init(env, exports);
-    AudioWrapper::Init(env, exports);
+  AV1RtpPacketizerWrapper::Init(env, exports);
+  H264RtpPacketizerWrapper::Init(env, exports);
+  H265RtpPacketizerWrapper::Init(env, exports);
+  RtcpNackResponderWrapper::Init(env, exports);
+  RtcpReceivingSessionWrapper::Init(env, exports);
+  RtcpSrReporterWrapper::Init(env, exports);
+  RtpPacketizationConfigWrapper::Init(env, exports);
+  RtpPacketizerWrapper::Init(env, exports);
+  TrackWrapper::Init(env, exports);
+  VideoWrapper::Init(env, exports);
+  AudioWrapper::Init(env, exports);
 #endif
 
-    DataChannelWrapper::Init(env, exports);
-    IceUdpMuxListenerWrapper::Init(env, exports);
-    PeerConnectionWrapper::Init(env, exports);
+  DataChannelWrapper::Init(env, exports);
+  IceUdpMuxListenerWrapper::Init(env, exports);
+  PeerConnectionWrapper::Init(env, exports);
 
 #if RTC_ENABLE_WEBSOCKET == 1
-    WebSocketWrapper::Init(env, exports);
-    WebSocketServerWrapper::Init(env, exports);
+  WebSocketWrapper::Init(env, exports);
+  WebSocketServerWrapper::Init(env, exports);
 #endif
 
-    return exports;
+  return exports;
 }
 
 NODE_API_MODULE(nodeDataChannel, InitAll)