@lng2004/node-datachannel 0.31.0-20251228

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

@@ -0,0 +1,52 @@
+#ifndef MEDIA_AUDIO_WRAPPER_H
+#define MEDIA_AUDIO_WRAPPER_H
+
+#include <unordered_set>
+
+#include <napi.h>
+#include <rtc/rtc.hpp>
+
+class AudioWrapper : public Napi::ObjectWrap<AudioWrapper>
+{
+public:
+  static Napi::FunctionReference constructor;
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  AudioWrapper(const Napi::CallbackInfo &info);
+  ~AudioWrapper();
+
+  rtc::Description::Audio getAudioInstance();
+
+  // Functions
+  void addAudioCodec(const Napi::CallbackInfo &info);
+  void addOpusCodec(const Napi::CallbackInfo &info);
+
+  // class Entry
+  Napi::Value direction(const Napi::CallbackInfo &info);
+  Napi::Value generateSdp(const Napi::CallbackInfo &info);
+  Napi::Value mid(const Napi::CallbackInfo &info);
+  void setDirection(const Napi::CallbackInfo &info);
+
+  // class Media
+  Napi::Value description(const Napi::CallbackInfo &info);
+  void removeFormat(const Napi::CallbackInfo &info);
+  void addSSRC(const Napi::CallbackInfo &info);
+  void removeSSRC(const Napi::CallbackInfo &info);
+  void replaceSSRC(const Napi::CallbackInfo &info);
+  Napi::Value hasSSRC(const Napi::CallbackInfo &info);
+  Napi::Value getSSRCs(const Napi::CallbackInfo &info);
+  Napi::Value getCNameForSsrc(const Napi::CallbackInfo &info);
+  void setBitrate(const Napi::CallbackInfo &info);
+  Napi::Value getBitrate(const Napi::CallbackInfo &info);
+  Napi::Value hasPayloadType(const Napi::CallbackInfo &info);
+  void addRTXCodec(const Napi::CallbackInfo &info);
+  void addRTPMap(const Napi::CallbackInfo &info);
+  void parseSdpLine(const Napi::CallbackInfo &info);
+
+  // Callbacks
+
+private:
+  static std::unordered_set<AudioWrapper *> instances;
+  std::shared_ptr<rtc::Description::Audio> mAudioPtr = nullptr;
+};
+
+#endif // MEDIA_AUDIO_WRAPPER_H

package/src/cpp/media-av1packetization.cpp

@@ -0,0 +1,24 @@
+#include "media-av1packetization.h"
+
+using Packetization = rtc::AV1RtpPacketizer::Packetization;
+
+std::optional<Packetization> strToPacketization(const std::string &packAsStr)
+{
+  if (packAsStr == "Obu")
+    return Packetization::Obu;
+  if (packAsStr == "TemporalUnit")
+    return Packetization::TemporalUnit;
+  return {};
+}
+
+std::string packetizationToStr(rtc::AV1RtpPacketizer::Packetization pack)
+{
+  switch (pack)
+  {
+  case Packetization::Obu:
+    return "Obu";
+  case Packetization::TemporalUnit:
+    return "TemporalUnit";
+  }
+  return "Unknown";
+}

package/src/cpp/media-av1packetization.h

@@ -0,0 +1,11 @@
+#ifndef MEDIA_AV1PACKETIZATION_H
+#define MEDIA_AV1PACKETIZATION_H
+
+#include <napi.h>
+#include <rtc/rtc.hpp>
+#include <optional>
+
+std::optional<rtc::AV1RtpPacketizer::Packetization> strToPacketization(const std::string &pktAsStr);
+std::string packetizationToStr(rtc::AV1RtpPacketizer::Packetization pkt);
+
+#endif // MEDIA_AV1PACKETIZATION_H

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

@@ -0,0 +1,126 @@
+#include "media-av1rtppacketizer-wrapper.h"
+#include "media-av1packetization.h"
+#include "media-rtppacketizationconfig-wrapper.h"
+#include "media-mediahandler-helper.h"
+
+Napi::FunctionReference AV1RtpPacketizerWrapper::constructor = Napi::FunctionReference();
+
+Napi::Object AV1RtpPacketizerWrapper::Init(Napi::Env env, Napi::Object exports)
+{
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = Napi::ObjectWrap<AV1RtpPacketizerWrapper>::DefineClass(env, "AV1RtpPacketizer",
+    {
+      // Instance Methods
+      InstanceMethod("addToChain", &AV1RtpPacketizerWrapper::addToChain),
+      // Accessors
+      InstanceAccessor("rtpConfig", &AV1RtpPacketizerWrapper::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("AV1RtpPacketizer", func);
+  return exports;
+}
+
+AV1RtpPacketizerWrapper::AV1RtpPacketizerWrapper(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<AV1RtpPacketizerWrapper>(info)
+{
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 2)
+  {
+    Napi::Error::New(env, "Expected 2 or 3 parameters").ThrowAsJavaScriptException();
+    return;
+  }
+
+  if (!info[0].IsString())
+  {
+    Napi::TypeError::New(env, "packetization must be \"Obu\" or \"TemporalUnit\"")
+      .ThrowAsJavaScriptException();
+    return;
+  }
+  auto packetizationOpt = strToPacketization(info[0].As<Napi::String>().Utf8Value());
+  if (!packetizationOpt.has_value())
+  {
+    Napi::TypeError::New(env, "packetization must be \"Obu\" or \"TemporalUnit\"")
+      .ThrowAsJavaScriptException();
+    return;
+  }
+  auto packetization = packetizationOpt.value();
+
+  if (!info[1].IsObject())
+  {
+    Napi::TypeError::New(env, "rtpConfig must be a RtpPacketizationConfig instance").ThrowAsJavaScriptException();
+    return;
+  }
+  auto obj = info[1].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();
+
+  size_t maxFragmentSize = rtc::RtpPacketizer::DefaultMaxFragmentSize;
+  if (info.Length() >= 3)
+  {
+    if (!info[2].IsNumber())
+    {
+      Napi::TypeError::New(env, "maxFragmentSize must be a number").ThrowAsJavaScriptException();
+      return;
+    }
+    maxFragmentSize = info[2].As<Napi::Number>().Uint32Value();
+  }
+
+  mPacketizerPtr = std::make_unique<rtc::AV1RtpPacketizer>(packetization, rtpConfig, maxFragmentSize);
+}
+
+AV1RtpPacketizerWrapper::~AV1RtpPacketizerWrapper()
+{
+  mPacketizerPtr.reset();
+  mRtpConfigObject.Reset();
+}
+
+std::shared_ptr<rtc::AV1RtpPacketizer> AV1RtpPacketizerWrapper::getPacketizerInstance() { return mPacketizerPtr; }
+
+void AV1RtpPacketizerWrapper::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 AV1RtpPacketizerWrapper::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-av1rtppacketizer-wrapper.h

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

package/src/cpp/media-direction.cpp

@@ -0,0 +1,43 @@
+#include "media-direction.h"
+
+rtc::Description::Direction strToDirection(const std::string dirAsStr)
+{
+  rtc::Description::Direction dir = rtc::Description::Direction::Unknown;
+
+  if (dirAsStr == "SendOnly")
+    dir = rtc::Description::Direction::SendOnly;
+  if (dirAsStr == "SendRecv")
+    dir = rtc::Description::Direction::SendRecv;
+  if (dirAsStr == "RecvOnly")
+    dir = rtc::Description::Direction::RecvOnly;
+  if (dirAsStr == "Inactive")
+    dir = rtc::Description::Direction::Inactive;
+
+  return dir;
+}
+
+std::string directionToStr(rtc::Description::Direction dir)
+{
+  std::string dirAsStr;
+  switch (dir)
+  {
+  case rtc::Description::Direction::Unknown:
+    dirAsStr = "Unknown";
+    break;
+  case rtc::Description::Direction::SendOnly:
+    dirAsStr = "SendOnly";
+    break;
+  case rtc::Description::Direction::RecvOnly:
+    dirAsStr = "RecvOnly";
+    break;
+  case rtc::Description::Direction::SendRecv:
+    dirAsStr = "SendRecv";
+    break;
+  case rtc::Description::Direction::Inactive:
+    dirAsStr = "Inactive";
+    break;
+  default:
+    dirAsStr = "UNKNOWN_DIR_TYPE";
+  }
+  return dirAsStr;
+}

package/src/cpp/media-direction.h

@@ -0,0 +1,10 @@
+#ifndef MEDIA_DIRECTION_H
+#define MEDIA_DIRECTION_H
+
+#include <napi.h>
+#include <rtc/rtc.hpp>
+
+rtc::Description::Direction strToDirection(const std::string dirAsStr);
+std::string directionToStr(rtc::Description::Direction dir);
+
+#endif // MEDIA_DIRECTION_H

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

@@ -0,0 +1,126 @@
+#include "media-h264rtppacketizer-wrapper.h"
+#include "media-h26xseparator.h"
+#include "media-rtppacketizationconfig-wrapper.h"
+#include "media-mediahandler-helper.h"
+
+Napi::FunctionReference H264RtpPacketizerWrapper::constructor = Napi::FunctionReference();
+
+Napi::Object H264RtpPacketizerWrapper::Init(Napi::Env env, Napi::Object exports)
+{
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = Napi::ObjectWrap<H264RtpPacketizerWrapper>::DefineClass(env, "H264RtpPacketizer",
+    {
+      // Instance Methods
+      InstanceMethod("addToChain", &H264RtpPacketizerWrapper::addToChain),
+      // Accessors
+      InstanceAccessor("rtpConfig", &H264RtpPacketizerWrapper::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("H264RtpPacketizer", func);
+  return exports;
+}
+
+H264RtpPacketizerWrapper::H264RtpPacketizerWrapper(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<H264RtpPacketizerWrapper>(info)
+{
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 2)
+  {
+    Napi::Error::New(env, "Expected 2 or 3 parameters").ThrowAsJavaScriptException();
+    return;
+  }
+
+  if (!info[0].IsString())
+  {
+    Napi::TypeError::New(env, "separator must be \"Length\", \"ShortStartSequence\", \"LongStartSequence\" or \"StartSequence\"")
+      .ThrowAsJavaScriptException();
+    return;
+  }
+  auto separatorOpt = strToSeparator(info[0].As<Napi::String>().Utf8Value());
+  if (!separatorOpt.has_value())
+  {
+    Napi::TypeError::New(env, "separator must be \"Length\", \"ShortStartSequence\", \"LongStartSequence\" or \"StartSequence\"")
+      .ThrowAsJavaScriptException();
+    return;
+  }
+  auto separator = separatorOpt.value();
+
+  if (!info[1].IsObject())
+  {
+    Napi::TypeError::New(env, "rtpConfig must be a RtpPacketizationConfig instance").ThrowAsJavaScriptException();
+    return;
+  }
+  auto obj = info[1].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();
+
+  size_t maxFragmentSize = rtc::RtpPacketizer::DefaultMaxFragmentSize;
+  if (info.Length() >= 3)
+  {
+    if (!info[2].IsNumber())
+    {
+      Napi::TypeError::New(env, "maxFragmentSize must be a number").ThrowAsJavaScriptException();
+      return;
+    }
+    maxFragmentSize = info[2].As<Napi::Number>().Uint32Value();
+  }
+
+  mPacketizerPtr = std::make_unique<rtc::H264RtpPacketizer>(separator, rtpConfig, maxFragmentSize);
+}
+
+H264RtpPacketizerWrapper::~H264RtpPacketizerWrapper()
+{
+  mPacketizerPtr.reset();
+  mRtpConfigObject.Reset();
+}
+
+std::shared_ptr<rtc::H264RtpPacketizer> H264RtpPacketizerWrapper::getPacketizerInstance() { return mPacketizerPtr; }
+
+void H264RtpPacketizerWrapper::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 H264RtpPacketizerWrapper::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-h264rtppacketizer-wrapper.h

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

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

@@ -0,0 +1,126 @@
+#include "media-h265rtppacketizer-wrapper.h"
+#include "media-h26xseparator.h"
+#include "media-rtppacketizationconfig-wrapper.h"
+#include "media-mediahandler-helper.h"
+
+Napi::FunctionReference H265RtpPacketizerWrapper::constructor = Napi::FunctionReference();
+
+Napi::Object H265RtpPacketizerWrapper::Init(Napi::Env env, Napi::Object exports)
+{
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = Napi::ObjectWrap<H265RtpPacketizerWrapper>::DefineClass(env, "H265RtpPacketizer",
+    {
+      // Instance Methods
+      InstanceMethod("addToChain", &H265RtpPacketizerWrapper::addToChain),
+      // Accessors
+      InstanceAccessor("rtpConfig", &H265RtpPacketizerWrapper::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("H265RtpPacketizer", func);
+  return exports;
+}
+
+H265RtpPacketizerWrapper::H265RtpPacketizerWrapper(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<H265RtpPacketizerWrapper>(info)
+{
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 2)
+  {
+    Napi::Error::New(env, "Expected 2 or 3 parameters").ThrowAsJavaScriptException();
+    return;
+  }
+
+  if (!info[0].IsString())
+  {
+    Napi::TypeError::New(env, "separator must be \"Length\", \"ShortStartSequence\", \"LongStartSequence\" or \"StartSequence\"")
+      .ThrowAsJavaScriptException();
+    return;
+  }
+  auto separatorOpt = strToSeparator(info[0].As<Napi::String>().Utf8Value());
+  if (!separatorOpt.has_value())
+  {
+    Napi::TypeError::New(env, "separator must be \"Length\", \"ShortStartSequence\", \"LongStartSequence\" or \"StartSequence\"")
+      .ThrowAsJavaScriptException();
+    return;
+  }
+  auto separator = separatorOpt.value();
+
+  if (!info[1].IsObject())
+  {
+    Napi::TypeError::New(env, "rtpConfig must be a RtpPacketizationConfig instance").ThrowAsJavaScriptException();
+    return;
+  }
+  auto obj = info[1].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();
+
+  size_t maxFragmentSize = rtc::RtpPacketizer::DefaultMaxFragmentSize;
+  if (info.Length() >= 3)
+  {
+    if (!info[2].IsNumber())
+    {
+      Napi::TypeError::New(env, "maxFragmentSize must be a number").ThrowAsJavaScriptException();
+      return;
+    }
+    maxFragmentSize = info[2].As<Napi::Number>().Uint32Value();
+  }
+
+  mPacketizerPtr = std::make_unique<rtc::H265RtpPacketizer>(separator, rtpConfig, maxFragmentSize);
+}
+
+H265RtpPacketizerWrapper::~H265RtpPacketizerWrapper()
+{
+  mPacketizerPtr.reset();
+  mRtpConfigObject.Reset();
+}
+
+std::shared_ptr<rtc::H265RtpPacketizer> H265RtpPacketizerWrapper::getPacketizerInstance() { return mPacketizerPtr; }
+
+void H265RtpPacketizerWrapper::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 H265RtpPacketizerWrapper::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-h265rtppacketizer-wrapper.h

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

package/src/cpp/media-h26xseparator.cpp

@@ -0,0 +1,32 @@
+#include "media-h26xseparator.h"
+
+using Separator = rtc::NalUnit::Separator;
+
+std::optional<Separator> strToSeparator(const std::string &sepAsStr)
+{
+  if (sepAsStr == "Length")
+    return Separator::Length;
+  if (sepAsStr == "ShortStartSequence")
+    return Separator::ShortStartSequence;
+  if (sepAsStr == "LongStartSequence")
+    return Separator::LongStartSequence;
+  if (sepAsStr == "StartSequence")
+    return Separator::StartSequence;
+  return {};
+}
+
+std::string separatorToStr(rtc::NalUnit::Separator sep)
+{
+  switch (sep)
+  {
+  case Separator::Length:
+    return "Length";
+  case Separator::ShortStartSequence:
+    return "ShortStartSequence";
+  case Separator::LongStartSequence:
+    return "LongStartSequence";
+  case Separator::StartSequence:
+    return "StartSequence";
+  }
+  return "Unknown";
+}

package/src/cpp/media-h26xseparator.h

@@ -0,0 +1,11 @@
+#ifndef MEDIA_H26XSEPARATOR_H
+#define MEDIA_H26XSEPARATOR_H
+
+#include <napi.h>
+#include <rtc/rtc.hpp>
+#include <optional>
+
+std::optional<rtc::NalUnit::Separator> strToSeparator(const std::string &sepAsStr);
+std::string separatorToStr(rtc::NalUnit::Separator sep);
+
+#endif // MEDIA_H26XSEPARATOR_H