node-datachannel 0.8.0 → 0.9.0

package/.github/workflows/npm-publish-manual.yml

@@ -13,7 +13,7 @@ jobs:
       - name: Set up Node.js
         uses: actions/setup-node@v1
         with:
-          node-version: 16.x
+          node-version: 20.x
           registry-url: "https://registry.npmjs.org"
       - name: Publish
         run: |

package/CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.15)
 cmake_policy(SET CMP0091 NEW)
 cmake_policy(SET CMP0042 NEW)
 
-project(node_datachannel VERSION 0.8.0)
+project(node_datachannel VERSION 0.9.0)
 
 # -Dnapi_build_version=8
 add_definitions(-DNAPI_VERSION=8)
@@ -29,7 +29,7 @@ include(FetchContent)
 FetchContent_Declare(
     libdatachannel
     GIT_REPOSITORY https://github.com/paullouisageneau/libdatachannel.git
-    GIT_TAG "v0.20.3"
+    GIT_TAG "v0.21.0"
 )
 
 option(NO_MEDIA "Disable media transport support in libdatachannel" OFF)

package/lib/index.d.cts

@@ -180,6 +180,7 @@ export class Track {
     isClosed(): boolean;
     bufferedAmount(): number;
     maxMessageSize(): number;
+    requestBitrate(bitRate: number): boolean;
     setBufferedAmountLowThreshold(newSize: number): void;
     requestKeyframe(): boolean;
     setMediaHandler(handler: RtcpReceivingSession): void;

package/lib/index.d.ts

@@ -180,6 +180,7 @@ export class Track {
     isClosed(): boolean;
     bufferedAmount(): number;
     maxMessageSize(): number;
+    requestBitrate(bitRate: number): boolean;
     setBufferedAmountLowThreshold(newSize: number): void;
     requestKeyframe(): boolean;
     setMediaHandler(handler: RtcpReceivingSession): void;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-datachannel",
-    "version": "0.8.0",
+    "version": "0.9.0",
     "description": "libdatachannel node bindings",
     "type": "module",
     "exports": {
@@ -99,4 +99,4 @@
         "prebuild-install": "^7.0.1",
         "rollup": "^4.14.1"
     }
-}
+}

package/src/data-channel-wrapper.cpp

@@ -58,6 +58,10 @@ DataChannelWrapper::DataChannelWrapper(const Napi::CallbackInfo &info) : Napi::O
     PLOG_DEBUG << "Constructor called";
     mDataChannelPtr = *(info[0].As<Napi::External<std::shared_ptr<rtc::DataChannel>>>().Data());
     PLOG_DEBUG << "Data Channel created";
+
+    // Closed callback must be set to trigger cleanup
+    mOnClosedCallback = std::make_unique<ThreadSafeCallback>(Napi::Function::New(info.Env(), [](const Napi::CallbackInfo&){}));
+
     instances.insert(this);
 }
 

package/src/media-audio-wrapper.cpp

@@ -390,9 +390,8 @@ void AudioWrapper::setBitrate(const Napi::CallbackInfo &info)
         return;
     }
 
-    int bitRate = static_cast<int>(info[0].As<Napi::Number>().ToNumber());
-
-    mAudioPtr->setBitrate(bitRate);
+    unsigned int bitrate = static_cast<uint32_t>(info[0].As<Napi::Number>().ToNumber());
+    mAudioPtr->setBitrate(bitrate);
 }
 
 Napi::Value AudioWrapper::getBitrate(const Napi::CallbackInfo &info)
@@ -428,9 +427,9 @@ void AudioWrapper::addRTXCodec(const Napi::CallbackInfo &info)
         return;
     }
 
-    unsigned int payloadType = static_cast<unsigned int>(info[0].As<Napi::Number>().ToNumber());
-    unsigned int originalPayloadType = static_cast<unsigned int>(info[1].As<Napi::Number>().ToNumber());
-    unsigned int clockRate = static_cast<unsigned int>(info[2].As<Napi::Number>().ToNumber());
+    int payloadType = static_cast<int32_t>(info[0].As<Napi::Number>().ToNumber());
+    int originalPayloadType = static_cast<int32_t>(info[1].As<Napi::Number>().ToNumber());
+    unsigned int clockRate = static_cast<uint32_t>(info[2].As<Napi::Number>().ToNumber());
 
     mAudioPtr->addRtxCodec(payloadType, originalPayloadType, clockRate);
 }

package/src/media-rtcpreceivingsession-wrapper.cpp

@@ -51,13 +51,12 @@ void RtcpReceivingSessionWrapper::requestBitrate(const Napi::CallbackInfo &info)
         return;
     }
 
-    unsigned int bitRate = static_cast<unsigned int>(info[0].As<Napi::Number>().ToNumber());
-
-    mSessionPtr->requestBitrate(bitRate);
+    unsigned int bitrate = static_cast<uint32_t>(info[0].As<Napi::Number>().ToNumber());
+    mSessionPtr->requestBitrate(bitrate);
 }
 
 Napi::Value RtcpReceivingSessionWrapper::requestKeyframe(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
     return Napi::Boolean::New(env, mSessionPtr->requestKeyframe());
-}
+}

package/src/media-track-wrapper.cpp

@@ -39,6 +39,7 @@ Napi::Object TrackWrapper::Init(Napi::Env env, Napi::Object exports)
             InstanceMethod("isOpen", &TrackWrapper::isOpen),
             InstanceMethod("isClosed", &TrackWrapper::isClosed),
             InstanceMethod("maxMessageSize", &TrackWrapper::maxMessageSize),
+            InstanceMethod("requestBitrate", &TrackWrapper::requestBitrate),
             InstanceMethod("requestKeyframe", &TrackWrapper::requestKeyframe),
             InstanceMethod("setMediaHandler", &TrackWrapper::setMediaHandler),
             InstanceMethod("onOpen", &TrackWrapper::onOpen),
@@ -56,7 +57,12 @@ Napi::Object TrackWrapper::Init(Napi::Env env, Napi::Object exports)
 
 TrackWrapper::TrackWrapper(const Napi::CallbackInfo &info) : Napi::ObjectWrap<TrackWrapper>(info)
 {
+    PLOG_DEBUG << "Constructor called";
     mTrackPtr = *(info[0].As<Napi::External<std::shared_ptr<rtc::Track>>>().Data());
+    PLOG_DEBUG << "Track created";
+
+    // Closed callback must be set to trigger cleanup
+    mOnClosedCallback = std::make_unique<ThreadSafeCallback>(Napi::Function::New(info.Env(), [](const Napi::CallbackInfo&){}));
 
     instances.insert(this);
 }
@@ -237,6 +243,27 @@ Napi::Value TrackWrapper::maxMessageSize(const Napi::CallbackInfo &info)
     }
 }
 
+Napi::Value TrackWrapper::requestBitrate(const Napi::CallbackInfo &info)
+{
+    if (!mTrackPtr)
+    {
+        Napi::Error::New(info.Env(), "requestBitrate() called on destroyed track").ThrowAsJavaScriptException();
+        return info.Env().Null();
+    }
+
+    Napi::Env env = info.Env();
+    int length = info.Length();
+
+    if (length < 1 || !info[0].IsNumber())
+    {
+        Napi::TypeError::New(env, "Number expected").ThrowAsJavaScriptException();
+        return info.Env().Null();
+    }
+
+    unsigned int bitrate = static_cast<uint32_t>(info[0].As<Napi::Number>());
+    return Napi::Boolean::New(env, mTrackPtr->requestBitrate(bitrate));
+}
+
 Napi::Value TrackWrapper::requestKeyframe(const Napi::CallbackInfo &info)
 {
     if (!mTrackPtr)

package/src/media-track-wrapper.h

@@ -30,6 +30,7 @@ public:
   Napi::Value isOpen(const Napi::CallbackInfo &info);
   Napi::Value isClosed(const Napi::CallbackInfo &info);
   Napi::Value maxMessageSize(const Napi::CallbackInfo &info);
+  Napi::Value requestBitrate(const Napi::CallbackInfo &info);
   Napi::Value requestKeyframe(const Napi::CallbackInfo &info);
   void setMediaHandler(const Napi::CallbackInfo &info);
 

package/src/media-video-wrapper.cpp

@@ -423,14 +423,12 @@ void VideoWrapper::setBitrate(const Napi::CallbackInfo &info)
         return;
     }
 
-    int bitRate = static_cast<int>(info[0].As<Napi::Number>().ToNumber());
-
-    mVideoPtr->setBitrate(bitRate);
+    unsigned int bitrate = info[0].As<Napi::Number>().ToNumber().Uint32Value();
+    mVideoPtr->setBitrate(bitrate);
 }
 
 Napi::Value VideoWrapper::getBitrate(const Napi::CallbackInfo &info)
 {
-
     return Napi::Number::New(info.Env(), mVideoPtr->bitrate());
 }
 
@@ -445,7 +443,7 @@ Napi::Value VideoWrapper::hasPayloadType(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    int payloadType = static_cast<int>(info[0].As<Napi::Number>().ToNumber());
+    int payloadType = static_cast<int32_t>(info[0].As<Napi::Number>().ToNumber());
 
     return Napi::Boolean::New(env, mVideoPtr->hasPayloadType(payloadType));
 }
@@ -461,9 +459,9 @@ void VideoWrapper::addRTXCodec(const Napi::CallbackInfo &info)
         return;
     }
 
-    unsigned int payloadType = static_cast<unsigned int>(info[0].As<Napi::Number>().ToNumber());
-    unsigned int originalPayloadType = static_cast<unsigned int>(info[1].As<Napi::Number>().ToNumber());
-    unsigned int clockRate = static_cast<unsigned int>(info[2].As<Napi::Number>().ToNumber());
+    int payloadType = static_cast<int32_t>(info[0].As<Napi::Number>().ToNumber());
+    int originalPayloadType = static_cast<int32_t>(info[1].As<Napi::Number>().ToNumber());
+    unsigned int clockRate = static_cast<uint32_t>(info[2].As<Napi::Number>().ToNumber());
 
     mVideoPtr->addRtxCodec(payloadType, originalPayloadType, clockRate);
 }

package/src/peer-connection-wrapper.cpp

@@ -237,7 +237,7 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
     // Create peer-connection
     try
     {
-        PLOG_DEBUG << "Creating a new peer";
+        PLOG_DEBUG << "Creating a new Peer Connection";
         mRtcPeerConnPtr = std::make_unique<rtc::PeerConnection>(rtcConfig);
     }
     catch (std::exception &ex)
@@ -246,6 +246,11 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
         return;
     }
 
+    PLOG_DEBUG << "Peer Connection created";
+
+    // State change callback must be set to trigger cleanup on close
+    mOnStateChangeCallback = std::make_unique<ThreadSafeCallback>(Napi::Function::New(info.Env(), [](const Napi::CallbackInfo&){}));
+
     instances.insert(this);
 }
 
@@ -552,10 +557,10 @@ Napi::Value PeerConnectionWrapper::createDataChannel(const Napi::CallbackInfo &i
                 switch (reliability.Get("type").As<Napi::Number>().Uint32Value())
                 {
                 case 1:
-                    init.reliability.rexmit = static_cast<int>(reliability.Get("rexmit").As<Napi::Number>().ToNumber());
+                    init.reliability.rexmit = int(reliability.Get("rexmit").As<Napi::Number>().ToNumber().Uint32Value());
                     break;
                 case 2:
-                    init.reliability.rexmit = std::chrono::milliseconds(reliability.Get("rexmit").As<Napi::Number>().Uint32Value());
+                    init.reliability.rexmit = std::chrono::milliseconds(reliability.Get("rexmit").As<Napi::Number>().Int32Value());
                     break;
                 }
             }
@@ -572,25 +577,31 @@ Napi::Value PeerConnectionWrapper::createDataChannel(const Napi::CallbackInfo &i
             init.reliability.unordered = !initConfig.Get("ordered").As<Napi::Boolean>();
         }
 
-        if (initConfig.Get("maxPacketLifeTime").IsNumber() && initConfig.Get("maxRetransmits").IsNumber())
+
+        if (!initConfig.Get("maxPacketLifeTime").IsUndefined() && !initConfig.Get("maxPacketLifeTime").IsNull() &&
+            !initConfig.Get("maxRetransmits").IsUndefined() && !initConfig.Get("maxRetransmits").IsNull())
         {
             Napi::TypeError::New(env, "Wrong DataChannel Init Config, maxPacketLifeTime and maxRetransmits are exclusive").ThrowAsJavaScriptException();
             return info.Env().Null();
         }
 
-        if (initConfig.Get("maxPacketLifeTime").IsNumber())
+        if (!initConfig.Get("maxPacketLifeTime").IsUndefined() && !initConfig.Get("maxPacketLifeTime").IsNull())
         {
-            init.reliability.type = rtc::Reliability::Type::Timed;
-            init.reliability.rexmit = std::chrono::milliseconds(initConfig.Get("maxPacketLifeTime").As<Napi::Number>().Uint32Value());
-        }
-        else if (initConfig.Get("maxRetransmits").IsNumber())
-        {
-            init.reliability.type = rtc::Reliability::Type::Rexmit;
-            init.reliability.rexmit = int(initConfig.Get("maxRetransmits").As<Napi::Number>().Uint32Value());
+            if (!initConfig.Get("maxPacketLifeTime").IsNumber())
+            {
+                Napi::TypeError::New(env, "Wrong DataChannel Init Config (maxPacketLifeTime)").ThrowAsJavaScriptException();
+                return info.Env().Null();
+            }
+            init.reliability.maxPacketLifeTime = std::chrono::milliseconds(initConfig.Get("maxPacketLifeTime").As<Napi::Number>().Uint32Value());
         }
-        else
+        else if (!initConfig.Get("maxRetransmits").IsUndefined() && !initConfig.Get("maxRetransmits").IsNull())
         {
-            init.reliability.type = rtc::Reliability::Type::Reliable;
+            if (!initConfig.Get("maxRetransmits").IsNumber())
+            {
+                Napi::TypeError::New(env, "Wrong DataChannel Init Config (maxRetransmits)").ThrowAsJavaScriptException();
+                return info.Env().Null();
+            }
+            init.reliability.maxRetransmits = int(initConfig.Get("maxRetransmits").As<Napi::Number>().Int32Value());
         }
     }
 

package/src/thread-safe-callback.cpp

@@ -9,16 +9,16 @@ const char *ThreadSafeCallback::CancelException::what() const throw()
 
 ThreadSafeCallback::ThreadSafeCallback(Napi::Function callback)
 {
-    if (!callback.IsFunction())
-        throw Napi::Error::New(callback.Env(), "Callback must be a function");
-
     Napi::Env env = callback.Env();
 
-    receiver = Napi::Persistent(static_cast<Napi::Value>(Napi::Object::New(env)));
+    if (!callback.IsFunction())
+        throw Napi::Error::New(env, "Callback must be a function");
+
     tsfn = tsfn_t::New(env,
                        std::move(callback),
                        "ThreadSafeCallback callback",
-                       0, 1, &receiver);
+                       0, // unlimited queue
+                       1);
 }
 
 ThreadSafeCallback::~ThreadSafeCallback()
@@ -38,10 +38,10 @@ void ThreadSafeCallback::call(arg_func_t argFunc, cleanup_func_t cleanupFunc)
 
 void ThreadSafeCallback::callbackFunc(Napi::Env env,
                                       Napi::Function callback,
-                                      Napi::Reference<Napi::Value> *context,
+                                      ContextType *context,
                                       CallbackData *data)
 {
-    // if env is gone this could mean cb fn has changed. See issue#176
+    // if env is gone, it could mean this cb was destroyed. See issue#176
     if (!data || !env)
         return;
 
@@ -59,9 +59,10 @@ void ThreadSafeCallback::callbackFunc(Napi::Env env,
         return;
     }
 
-    if (env && callback)
+    if (callback)
     {
-        callback.Call(context->Value(), args);
-        cleanup();
+        callback.Call(args);
     }
+
+    cleanup();
 }

package/src/thread-safe-callback.h

@@ -30,6 +30,7 @@ public:
     };
 
 private:
+    using ContextType = std::nullptr_t;
     struct CallbackData
     {
         arg_func_t argFunc;
@@ -38,12 +39,10 @@ private:
 
     static void callbackFunc(Napi::Env env,
                              Napi::Function callback,
-                             Napi::Reference<Napi::Value> *context,
+                             ContextType *context,
                              CallbackData *data);
 
-    using tsfn_t = Napi::TypedThreadSafeFunction<Napi::Reference<Napi::Value>, CallbackData, callbackFunc>;
-
-    Napi::Reference<Napi::Value> receiver;
+    using tsfn_t = Napi::TypedThreadSafeFunction<ContextType, CallbackData, callbackFunc>;
     tsfn_t tsfn;
 };
 

package/src/web-socket-wrapper.cpp

@@ -238,6 +238,10 @@ WebSocketWrapper::WebSocketWrapper(const Napi::CallbackInfo &info) : Napi::Objec
     }
 
     PLOG_DEBUG << "WebSocket created";
+
+    // Closed callback must set to trigger cleanup
+    mOnClosedCallback = std::make_unique<ThreadSafeCallback>(Napi::Function::New(info.Env(), [](const Napi::CallbackInfo&){}));
+
     instances.insert(this);
 }
 
@@ -471,7 +475,7 @@ Napi::Value WebSocketWrapper::remoteAddress(const Napi::CallbackInfo &info)
 
     if (!mWebSocketPtr)
     {
-        return env.Undefined(); 
+        return env.Undefined();
     }
 
     try
@@ -500,7 +504,7 @@ Napi::Value WebSocketWrapper::path(const Napi::CallbackInfo &info)
 
     if (!mWebSocketPtr)
     {
-        return env.Undefined(); 
+        return env.Undefined();
     }
 
     try