node-datachannel 0.29.0 → 0.31.0

package/src/cpp/media-mediahandler-helper.h

@@ -0,0 +1,11 @@
+#ifndef MEDIA_MEDIAHANDLER_HELPER_H
+#define MEDIA_MEDIAHANDLER_HELPER_H
+
+#include <memory>
+
+#include <napi.h>
+#include <rtc/rtc.hpp>
+
+std::shared_ptr<rtc::MediaHandler> asMediaHandler(const Napi::Object &obj);
+
+#endif // MEDIA_MEDIAHANDLER_HELPER_H

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

@@ -0,0 +1,68 @@
+#include "media-rtcpnackresponder-wrapper.h"
+#include "media-mediahandler-helper.h"
+
+Napi::FunctionReference RtcpNackResponderWrapper::constructor = Napi::FunctionReference();
+
+Napi::Object RtcpNackResponderWrapper::Init(Napi::Env env, Napi::Object exports)
+{
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = Napi::ObjectWrap<RtcpNackResponderWrapper>::DefineClass(env, "RtcpNackResponder",
+    {
+      // Instance Methods
+      InstanceMethod("addToChain", &RtcpNackResponderWrapper::addToChain),
+    });
+
+  // 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("RtcpNackResponder", func);
+  return exports;
+}
+
+RtcpNackResponderWrapper::RtcpNackResponderWrapper(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<RtcpNackResponderWrapper>(info)
+{
+  Napi::Env env = info.Env();
+
+  size_t maxSize = rtc::RtcpNackResponder::DefaultMaxSize;
+  if (info.Length() >= 1)
+  {
+    if (!info[0].IsNumber())
+    {
+      Napi::TypeError::New(env, "maxSize must be a number").ThrowAsJavaScriptException();
+      return;
+    }
+    maxSize = info[0].As<Napi::Number>().Int64Value();
+  }
+  mResponderPtr = std::make_unique<rtc::RtcpNackResponder>(maxSize);
+}
+
+RtcpNackResponderWrapper::~RtcpNackResponderWrapper()
+{
+  mResponderPtr.reset();
+}
+
+std::shared_ptr<rtc::RtcpNackResponder> RtcpNackResponderWrapper::getResponderInstance() { return mResponderPtr; }
+
+void RtcpNackResponderWrapper::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;
+  }
+  mResponderPtr->addToChain(mediaHandler);
+}

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

@@ -0,0 +1,28 @@
+#ifndef MEDIA_RTCPNACKRESPONDER_WRAPPER_H
+#define MEDIA_RTCPNACKRESPONDER_WRAPPER_H
+
+#include <memory>
+#include <unordered_set>
+
+#include <napi.h>
+#include <rtc/rtc.hpp>
+
+class RtcpNackResponderWrapper : public Napi::ObjectWrap<RtcpNackResponderWrapper>
+{
+public:
+  static Napi::FunctionReference constructor;
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  RtcpNackResponderWrapper(const Napi::CallbackInfo &info);
+  ~RtcpNackResponderWrapper();
+  std::shared_ptr<rtc::RtcpNackResponder> getResponderInstance();
+
+  // Functions
+  void addToChain(const Napi::CallbackInfo &info);
+
+  // Callbacks
+
+private:
+  std::shared_ptr<rtc::RtcpNackResponder> mResponderPtr = nullptr;
+};
+
+#endif // MEDIA_RTCPNACKRESPONDER_WRAPPER_H

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

@@ -1,44 +1,57 @@
 #include "media-rtcpreceivingsession-wrapper.h"
+#include "media-mediahandler-helper.h"
 
 Napi::FunctionReference RtcpReceivingSessionWrapper::constructor = Napi::FunctionReference();
-std::unordered_set<RtcpReceivingSessionWrapper *> RtcpReceivingSessionWrapper::instances;
 
 Napi::Object RtcpReceivingSessionWrapper::Init(Napi::Env env, Napi::Object exports)
 {
-    Napi::HandleScope scope(env);
+  Napi::HandleScope scope(env);
 
-    Napi::Function func = Napi::ObjectWrap<RtcpReceivingSessionWrapper>::DefineClass(
-        env,
-        "RtcpReceivingSession",
-        {
-            // Instance Methods
-        });
-
-    // If this is not the first call, we don't want to reassign the constructor (hot-reload problem)
-    if(constructor.IsEmpty())
+  Napi::Function func = Napi::ObjectWrap<RtcpReceivingSessionWrapper>::DefineClass(env, "RtcpReceivingSession",
     {
-        constructor = Napi::Persistent(func);
-        constructor.SuppressDestruct();
-    }
-
-    exports.Set("RtcpReceivingSession", func);
-    return exports;
+      // Instance Methods
+      InstanceMethod("addToChain", &RtcpReceivingSessionWrapper::addToChain),
+    });
+
+  // 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("RtcpReceivingSession", func);
+  return exports;
 }
 
-RtcpReceivingSessionWrapper::RtcpReceivingSessionWrapper(const Napi::CallbackInfo &info) : Napi::ObjectWrap<RtcpReceivingSessionWrapper>(info)
+RtcpReceivingSessionWrapper::RtcpReceivingSessionWrapper(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<RtcpReceivingSessionWrapper>(info)
 {
-    Napi::Env env = info.Env();
-    mSessionPtr = std::make_unique<rtc::RtcpReceivingSession>();
-    instances.insert(this);
+  Napi::Env env = info.Env();
+  mSessionPtr = std::make_unique<rtc::RtcpReceivingSession>();
 }
 
 RtcpReceivingSessionWrapper::~RtcpReceivingSessionWrapper()
 {
-    mSessionPtr.reset();
-    instances.erase(this);
+  mSessionPtr.reset();
 }
 
-std::shared_ptr<rtc::RtcpReceivingSession> RtcpReceivingSessionWrapper::getSessionInstance()
+std::shared_ptr<rtc::RtcpReceivingSession> RtcpReceivingSessionWrapper::getSessionInstance() { return mSessionPtr; }
+
+void RtcpReceivingSessionWrapper::addToChain(const Napi::CallbackInfo &info)
 {
-    return mSessionPtr;
+  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;
+  }
+  mSessionPtr->addToChain(mediaHandler);
 }

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

@@ -1,17 +1,12 @@
 #ifndef MEDIA_RTCPRECEIVINGSESSION_WRAPPER_H
 #define MEDIA_RTCPRECEIVINGSESSION_WRAPPER_H
 
-#include <iostream>
-#include <string>
-#include <variant>
 #include <memory>
 #include <unordered_set>
 
 #include <napi.h>
 #include <rtc/rtc.hpp>
 
-#include "thread-safe-callback.h"
-
 class RtcpReceivingSessionWrapper : public Napi::ObjectWrap<RtcpReceivingSessionWrapper>
 {
 public:
@@ -22,11 +17,11 @@ public:
   std::shared_ptr<rtc::RtcpReceivingSession> getSessionInstance();
 
   // Functions
+  void addToChain(const Napi::CallbackInfo &info);
 
   // Callbacks
 
 private:
-  static std::unordered_set<RtcpReceivingSessionWrapper *> instances;
   std::shared_ptr<rtc::RtcpReceivingSession> mSessionPtr = nullptr;
 };
 

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

@@ -0,0 +1,93 @@
+#include "media-rtcpsrreporter-wrapper.h"
+#include "media-rtppacketizationconfig-wrapper.h"
+#include "media-mediahandler-helper.h"
+
+Napi::FunctionReference RtcpSrReporterWrapper::constructor = Napi::FunctionReference();
+
+Napi::Object RtcpSrReporterWrapper::Init(Napi::Env env, Napi::Object exports)
+{
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = Napi::ObjectWrap<RtcpSrReporterWrapper>::DefineClass(env, "RtcpSrReporter",
+    {
+      // Instance Methods
+      InstanceMethod("addToChain", &RtcpSrReporterWrapper::addToChain),
+      // Accessors
+      InstanceAccessor("rtpConfig", &RtcpSrReporterWrapper::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("RtcpSrReporter", func);
+  return exports;
+}
+
+RtcpSrReporterWrapper::RtcpSrReporterWrapper(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<RtcpSrReporterWrapper>(info)
+{
+  Napi::Env env = info.Env();
+
+  if (!info[0].IsObject())
+  {
+    Napi::TypeError::New(env, "Expected a RtpPacketizationConfig object").ThrowAsJavaScriptException();
+    return;
+  }
+
+  auto obj = info[0].As<Napi::Object>();
+  if (!obj.InstanceOf(RtpPacketizationConfigWrapper::constructor.Value()))
+  {
+    Napi::TypeError::New(env, "Expected a RtpPacketizationConfig object").ThrowAsJavaScriptException();
+    return;
+  }
+  // store original JS object so we can return it later
+  mRtpConfigObject = Napi::Persistent(obj);
+  mRtpConfigObject.SuppressDestruct();
+  auto config = RtpPacketizationConfigWrapper::Unwrap(obj);
+  mReporterPtr = std::make_unique<rtc::RtcpSrReporter>(config->getConfigInstance());
+}
+
+RtcpSrReporterWrapper::~RtcpSrReporterWrapper()
+{
+  mReporterPtr.reset();
+  mRtpConfigObject.Reset();
+}
+
+std::shared_ptr<rtc::RtcpSrReporter> RtcpSrReporterWrapper::getReporterInstance() { return mReporterPtr; }
+
+void RtcpSrReporterWrapper::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;
+  }
+  mReporterPtr->addToChain(mediaHandler);
+}
+
+Napi::Value RtcpSrReporterWrapper::getRtpPacketizationConfig(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+  if (!mReporterPtr)
+  {
+    Napi::Error::New(env, "getRtpPacketizationConfig() called on destroyed reporter").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (mRtpConfigObject.IsEmpty())
+    return env.Null();
+
+  return mRtpConfigObject.Value();
+}

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

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

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

@@ -0,0 +1,167 @@
+#include "media-rtppacketizationconfig-wrapper.h"
+
+Napi::FunctionReference RtpPacketizationConfigWrapper::constructor = Napi::FunctionReference();
+
+Napi::Object RtpPacketizationConfigWrapper::Init(Napi::Env env, Napi::Object exports)
+{
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = Napi::ObjectWrap<RtpPacketizationConfigWrapper>::DefineClass(env, "RtpPacketizationConfig",
+    {
+      // Instance Methods
+      InstanceAccessor("playoutDelayId",
+        &RtpPacketizationConfigWrapper::getPlayoutDelayId,
+        &RtpPacketizationConfigWrapper::setPlayoutDelayId
+      ),
+      InstanceAccessor("playoutDelayMin",
+        &RtpPacketizationConfigWrapper::getPlayoutDelayMin,
+        &RtpPacketizationConfigWrapper::setPlayoutDelayMin
+      ),
+      InstanceAccessor("playoutDelayMax",
+        &RtpPacketizationConfigWrapper::getPlayoutDelayMax,
+        &RtpPacketizationConfigWrapper::setPlayoutDelayMax
+      ),
+      InstanceAccessor("timestamp",
+        &RtpPacketizationConfigWrapper::getTimestamp,
+        &RtpPacketizationConfigWrapper::setTimestamp
+      ),
+      InstanceAccessor("clockRate",
+        &RtpPacketizationConfigWrapper::getClockRate,
+        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("RtpPacketizationConfig", func);
+  return exports;
+}
+
+RtpPacketizationConfigWrapper::RtpPacketizationConfigWrapper(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<RtpPacketizationConfigWrapper>(info)
+{
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 4)
+  {
+    Napi::Error::New(env, "RtpPacketizationConfig constructor requires 4 or 5 parameters").ThrowAsJavaScriptException();
+    return;
+  }
+
+  rtc::SSRC ssrc;
+  if (!info[0].IsNumber())
+  {
+    Napi::TypeError::New(env, "ssrc must be a number").ThrowAsJavaScriptException();
+    return;
+  }
+  ssrc = info[0].As<Napi::Number>().Uint32Value();
+
+  std::string cname;
+  if (!info[1].IsString())
+  {
+    Napi::TypeError::New(env, "cname must be a string").ThrowAsJavaScriptException();
+    return;
+  }
+  cname = info[1].As<Napi::String>().Utf8Value();
+
+  uint8_t payloadType;
+  if (!info[2].IsNumber())
+  {
+    Napi::TypeError::New(env, "payloadType must be a number").ThrowAsJavaScriptException();
+    return;
+  }
+  payloadType = info[2].As<Napi::Number>().Uint32Value();
+
+  uint32_t clockRate;
+  if (!info[3].IsNumber())
+  {
+    Napi::TypeError::New(env, "clockRate must be a number").ThrowAsJavaScriptException();
+    return;
+  }
+  clockRate = info[3].As<Napi::Number>().Uint32Value();
+
+  uint8_t videoOrientationId = 0;
+  if (info.Length() >= 5)
+  {
+    if (!info[4].IsNumber())
+    {
+      Napi::TypeError::New(env, "videoOrientationId must be a number").ThrowAsJavaScriptException();
+      return;
+    }
+    videoOrientationId = info[4].As<Napi::Number>().Uint32Value();
+  }
+  mConfigPtr = std::make_unique<rtc::RtpPacketizationConfig>(ssrc, cname, payloadType, clockRate, videoOrientationId);
+}
+
+RtpPacketizationConfigWrapper::~RtpPacketizationConfigWrapper()
+{
+  mConfigPtr.reset();
+}
+
+std::shared_ptr<rtc::RtpPacketizationConfig> RtpPacketizationConfigWrapper::getConfigInstance() { return mConfigPtr; }
+
+Napi::Value RtpPacketizationConfigWrapper::getPlayoutDelayId(const Napi::CallbackInfo &info)
+{
+  return Napi::Number::New(info.Env(), mConfigPtr->playoutDelayId);
+}
+void RtpPacketizationConfigWrapper::setPlayoutDelayId(const Napi::CallbackInfo &info, const Napi::Value &val)
+{
+  auto env = info.Env();
+  if (!val.IsNumber())
+  {
+    Napi::TypeError::New(env, "Expected a number").ThrowAsJavaScriptException();
+    return;
+  }
+  mConfigPtr->playoutDelayId = val.As<Napi::Number>().Uint32Value();
+}
+Napi::Value RtpPacketizationConfigWrapper::getPlayoutDelayMin(const Napi::CallbackInfo &info)
+{
+  return Napi::Number::New(info.Env(), mConfigPtr->playoutDelayMin);
+}
+void RtpPacketizationConfigWrapper::setPlayoutDelayMin(const Napi::CallbackInfo &info, const Napi::Value &val)
+{
+  auto env = info.Env();
+  if (!val.IsNumber())
+  {
+    Napi::TypeError::New(env, "Expected a number").ThrowAsJavaScriptException();
+    return;
+  }
+  mConfigPtr->playoutDelayMin = val.As<Napi::Number>().Uint32Value();
+}
+Napi::Value RtpPacketizationConfigWrapper::getPlayoutDelayMax(const Napi::CallbackInfo &info)
+{
+  return Napi::Number::New(info.Env(), mConfigPtr->playoutDelayMax);
+}
+void RtpPacketizationConfigWrapper::setPlayoutDelayMax(const Napi::CallbackInfo &info, const Napi::Value &val)
+{
+  auto env = info.Env();
+  if (!val.IsNumber())
+  {
+    Napi::TypeError::New(env, "Expected a number").ThrowAsJavaScriptException();
+    return;
+  }
+  mConfigPtr->playoutDelayMax = val.As<Napi::Number>().Uint32Value();
+}
+Napi::Value RtpPacketizationConfigWrapper::getTimestamp(const Napi::CallbackInfo &info)
+{
+  return Napi::Number::New(info.Env(), mConfigPtr->timestamp);
+}
+void RtpPacketizationConfigWrapper::setTimestamp(const Napi::CallbackInfo &info, const Napi::Value &val)
+{
+  auto env = info.Env();
+  if (!val.IsNumber())
+  {
+    Napi::TypeError::New(env, "Expected a number").ThrowAsJavaScriptException();
+    return;
+  }
+  mConfigPtr->timestamp = val.As<Napi::Number>().Uint32Value();
+}
+Napi::Value RtpPacketizationConfigWrapper::getClockRate(const Napi::CallbackInfo &info)
+{
+  return Napi::Number::New(info.Env(), mConfigPtr->clockRate);
+}

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