@lng2004/node-datachannel 0.31.0-20251228

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

@@ -0,0 +1,157 @@
+#include "ice-udp-mux-listener-wrapper.h"
+
+#include "plog/Log.h"
+
+#include <cctype>
+
+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();
+}
+
+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;
+}
+
+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);
+}
+
+IceUdpMuxListenerWrapper::~IceUdpMuxListenerWrapper()
+{
+  PLOG_DEBUG << "IceUdpMuxListenerWrapper Destructor called";
+  doCleanup();
+}
+
+void IceUdpMuxListenerWrapper::doCleanup()
+{
+  PLOG_DEBUG << "IceUdpMuxListenerWrapper::doCleanup() called";
+
+  if (iceUdpMuxListenerPtr)
+  {
+    iceUdpMuxListenerPtr->stop();
+    iceUdpMuxListenerPtr.reset();
+  }
+
+  mOnUnhandledStunRequestCallback.reset();
+  instances.erase(this);
+}
+
+Napi::Value IceUdpMuxListenerWrapper::port(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+
+  return Napi::Number::New(env, mPort);
+}
+
+Napi::Value IceUdpMuxListenerWrapper::address(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+
+  if (!mAddress.has_value())
+  {
+    return env.Undefined();
+  }
+
+  return Napi::String::New(env, mAddress.value());
+}
+
+void IceUdpMuxListenerWrapper::stop(const Napi::CallbackInfo &info)
+{
+  PLOG_DEBUG << "IceUdpMuxListenerWrapper::stop() called";
+  doCleanup();
+}
+
+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())
+  {
+    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)
+    {
+      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)";
+  });
+}

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

@@ -0,0 +1,43 @@
+#ifndef ICE_UDP_MUX_LISTENER_WRAPPER_H
+#define ICE_UDP_MUX_LISTENER_WRAPPER_H
+
+#include <napi.h>
+#include <rtc/rtc.hpp>
+#include <unordered_set>
+
+#include "thread-safe-callback.h"
+
+class IceUdpMuxListenerWrapper : public Napi::ObjectWrap<IceUdpMuxListenerWrapper>
+{
+public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  IceUdpMuxListenerWrapper(const Napi::CallbackInfo &info);
+  ~IceUdpMuxListenerWrapper();
+
+  // Functions
+  void stop(const Napi::CallbackInfo &info);
+  void onUnhandledStunRequest(const Napi::CallbackInfo &info);
+
+  // Stop listening on all ports
+  static void StopAll();
+
+  // Properties
+  Napi::Value port(const Napi::CallbackInfo &info);
+  Napi::Value address(const Napi::CallbackInfo &info);
+  Napi::Value unhandledStunRequestCallback(const Napi::CallbackInfo &info);
+
+  // Callback Ptrs
+  std::unique_ptr<ThreadSafeCallback> mOnUnhandledStunRequestCallback = nullptr;
+
+private:
+  static Napi::FunctionReference constructor;
+  static std::unordered_set<IceUdpMuxListenerWrapper *> instances;
+
+  void doCleanup();
+
+  std::optional<std::string> mAddress;
+  uint16_t mPort;
+  std::unique_ptr<rtc::IceUdpMuxListener> iceUdpMuxListenerPtr = nullptr;
+};
+
+#endif // ICE_UDP_MUX_LISTENER_WRAPPER_H

package/src/cpp/main.cpp

@@ -0,0 +1,58 @@
+#include <napi.h>
+#include "rtc-wrapper.h"
+#include "peer-connection-wrapper.h"
+#include "data-channel-wrapper.h"
+#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-pacinghandler-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"
+#endif
+
+#if RTC_ENABLE_WEBSOCKET == 1
+#include "web-socket-wrapper.h"
+#include "web-socket-server-wrapper.h"
+#endif
+
+Napi::Object InitAll(Napi::Env env, Napi::Object exports)
+{
+  RtcWrapper::Init(env, exports);
+
+#if RTC_ENABLE_MEDIA == 1
+  AV1RtpPacketizerWrapper::Init(env, exports);
+  H264RtpPacketizerWrapper::Init(env, exports);
+  H265RtpPacketizerWrapper::Init(env, exports);
+  PacingHandlerWrapper::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);
+
+#if RTC_ENABLE_WEBSOCKET == 1
+  WebSocketWrapper::Init(env, exports);
+  WebSocketServerWrapper::Init(env, exports);
+#endif
+
+  return exports;
+}
+
+NODE_API_MODULE(nodeDataChannel, InitAll)

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

@@ -0,0 +1,457 @@
+#include "media-audio-wrapper.h"
+#include "media-direction.h"
+
+Napi::FunctionReference AudioWrapper::constructor = Napi::FunctionReference();
+std::unordered_set<AudioWrapper *> AudioWrapper::instances;
+
+Napi::Object AudioWrapper::Init(Napi::Env env, Napi::Object exports)
+{
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = DefineClass(env, "Audio",
+                                    {
+                                        InstanceValue("media-type-audio", Napi::Boolean::New(env, true)),
+                                        InstanceMethod("addAudioCodec", &AudioWrapper::addAudioCodec),
+                                        InstanceMethod("addOpusCodec", &AudioWrapper::addOpusCodec),
+                                        InstanceMethod("direction", &AudioWrapper::direction),
+                                        InstanceMethod("generateSdp", &AudioWrapper::generateSdp),
+                                        InstanceMethod("mid", &AudioWrapper::mid),
+                                        InstanceMethod("setDirection", &AudioWrapper::setDirection),
+                                        InstanceMethod("description", &AudioWrapper::description),
+                                        InstanceMethod("removeFormat", &AudioWrapper::removeFormat),
+                                        InstanceMethod("addSSRC", &AudioWrapper::addSSRC),
+                                        InstanceMethod("removeSSRC", &AudioWrapper::removeSSRC),
+                                        InstanceMethod("replaceSSRC", &AudioWrapper::replaceSSRC),
+                                        InstanceMethod("hasSSRC", &AudioWrapper::hasSSRC),
+                                        InstanceMethod("getSSRCs", &AudioWrapper::getSSRCs),
+                                        InstanceMethod("getCNameForSsrc", &AudioWrapper::getCNameForSsrc),
+                                        InstanceMethod("setBitrate", &AudioWrapper::setBitrate),
+                                        InstanceMethod("getBitrate", &AudioWrapper::getBitrate),
+                                        InstanceMethod("hasPayloadType", &AudioWrapper::hasPayloadType),
+                                        InstanceMethod("addRTXCodec", &AudioWrapper::addRTXCodec),
+                                        InstanceMethod("addRTPMap", &AudioWrapper::addRTPMap),
+                                        InstanceMethod("parseSdpLine", &AudioWrapper::parseSdpLine),
+                                    });
+
+  // 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("Audio", func);
+  return exports;
+}
+
+AudioWrapper::AudioWrapper(const Napi::CallbackInfo &info) : Napi::ObjectWrap<AudioWrapper>(info)
+{
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  std::string mid = "audio";
+  rtc::Description::Direction dir = rtc::Description::Direction::SendOnly;
+
+  // optional
+  if (length > 0)
+  {
+    if (!info[0].IsString())
+    {
+      Napi::TypeError::New(env, "mid (String) expected").ThrowAsJavaScriptException();
+      return;
+    }
+    mid = info[0].As<Napi::String>().ToString();
+  }
+
+  // ootional
+  if (length > 1)
+  {
+    if (!info[1].IsString())
+    {
+      Napi::TypeError::New(env, "direction (String) expected").ThrowAsJavaScriptException();
+      return;
+    }
+
+    std::string dirAsStr = info[1].As<Napi::String>().ToString();
+    dir = strToDirection(dirAsStr);
+  }
+
+  mAudioPtr = std::make_unique<rtc::Description::Audio>(mid, dir);
+
+  instances.insert(this);
+}
+
+AudioWrapper::~AudioWrapper()
+{
+  mAudioPtr.reset();
+  instances.erase(this);
+}
+
+rtc::Description::Audio AudioWrapper::getAudioInstance() { return *(mAudioPtr.get()); }
+
+void AudioWrapper::addAudioCodec(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  if (length < 2 || !info[0].IsNumber() || !info[1].IsString())
+  {
+    Napi::TypeError::New(env, "We expect (Number, String, String[optional]) as param").ThrowAsJavaScriptException();
+    return;
+  }
+
+  int payloadType = info[0].As<Napi::Number>().ToNumber();
+  std::string codec = info[1].As<Napi::String>().ToString();
+  std::optional<std::string> profile = std::nullopt;
+
+  if (length > 2)
+  {
+    if (!info[2].IsString())
+    {
+      Napi::TypeError::New(env, "profile (String) expected").ThrowAsJavaScriptException();
+      return;
+    }
+    profile = info[2].As<Napi::String>().ToString();
+  }
+
+  mAudioPtr->addAudioCodec(payloadType, codec, profile);
+}
+
+void AudioWrapper::addOpusCodec(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();
+  std::optional<std::string> profile = rtc::DEFAULT_OPUS_AUDIO_PROFILE;
+
+  if (length > 1)
+  {
+    if (!info[1].IsString())
+    {
+      Napi::TypeError::New(env, "profile (String) expected").ThrowAsJavaScriptException();
+      return;
+    }
+    profile = info[1].As<Napi::String>().ToString();
+  }
+
+  mAudioPtr->addOpusCodec(payloadType, profile);
+}
+
+Napi::Value AudioWrapper::direction(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+  return Napi::String::New(env, directionToStr(mAudioPtr->direction()));
+}
+
+Napi::Value AudioWrapper::generateSdp(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  if (length < 3 || !info[0].IsString() || !info[1].IsString() || !info[2].IsNumber())
+  {
+    Napi::TypeError::New(env, "We expect (String, String, Number) as param").ThrowAsJavaScriptException();
+    return Napi::String::New(env, "");
+  }
+
+  std::string eol = info[0].As<Napi::String>().ToString();
+  std::string addr = info[1].As<Napi::String>().ToString();
+  uint16_t port = info[2].As<Napi::Number>().Uint32Value();
+
+  return Napi::String::New(env, mAudioPtr->generateSdp(eol, addr, port));
+}
+
+Napi::Value AudioWrapper::mid(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+  return Napi::String::New(env, mAudioPtr->mid());
+}
+
+void AudioWrapper::setDirection(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  if (length < 1 || !info[0].IsString())
+  {
+    Napi::TypeError::New(env, "We expect (String) as param").ThrowAsJavaScriptException();
+    return;
+  }
+
+  std::string dirAsStr = info[0].As<Napi::String>().ToString();
+  rtc::Description::Direction dir = strToDirection(dirAsStr);
+  mAudioPtr->setDirection(dir);
+}
+
+Napi::Value AudioWrapper::description(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+  return Napi::String::New(env, mAudioPtr->description());
+}
+
+void AudioWrapper::removeFormat(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  if (length < 1 || !info[0].IsString())
+  {
+    Napi::TypeError::New(env, "We expect (String) as param").ThrowAsJavaScriptException();
+    return;
+  }
+
+  std::string fmt = info[0].As<Napi::String>().ToString();
+
+  mAudioPtr->removeFormat(fmt);
+}
+
+void AudioWrapper::addSSRC(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, String[optional], String[optional], String[optional]) as param")
+        .ThrowAsJavaScriptException();
+    return;
+  }
+
+  uint32_t ssrc = static_cast<uint32_t>(info[0].As<Napi::Number>().ToNumber());
+  std::optional<std::string> name;
+  std::optional<std::string> msid = std::nullopt;
+  std::optional<std::string> trackID = std::nullopt;
+
+  if (length > 1)
+  {
+    if (!info[1].IsString())
+    {
+      Napi::TypeError::New(env, "name as String expected").ThrowAsJavaScriptException();
+      return;
+    }
+    name = info[1].As<Napi::String>().ToString();
+  }
+
+  if (length > 2)
+  {
+    if (!info[2].IsString())
+    {
+      Napi::TypeError::New(env, "msid as String expected").ThrowAsJavaScriptException();
+      return;
+    }
+    msid = info[2].As<Napi::String>().ToString();
+  }
+
+  if (length > 3)
+  {
+    if (!info[3].IsString())
+    {
+      Napi::TypeError::New(env, "trackID as String expected").ThrowAsJavaScriptException();
+      return;
+    }
+    trackID = info[3].As<Napi::String>().ToString();
+  }
+
+  mAudioPtr->addSSRC(ssrc, name, msid, trackID);
+}
+
+void AudioWrapper::removeSSRC(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;
+  }
+
+  uint32_t ssrc = static_cast<uint32_t>(info[0].As<Napi::Number>().ToNumber());
+
+  mAudioPtr->removeSSRC(ssrc);
+}
+
+void AudioWrapper::replaceSSRC(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  if (length < 2 || !info[0].IsNumber() || !info[1].IsNumber())
+  {
+    Napi::TypeError::New(env,
+                         "We expect (Number, Number, String[optional], String[optional], String[optional]) as param")
+        .ThrowAsJavaScriptException();
+    return;
+  }
+
+  uint32_t ssrc = static_cast<uint32_t>(info[0].As<Napi::Number>().ToNumber());
+  uint32_t oldSsrc = static_cast<uint32_t>(info[1].As<Napi::Number>().ToNumber());
+  std::optional<std::string> name;
+  std::optional<std::string> msid = std::nullopt;
+  std::optional<std::string> trackID = std::nullopt;
+
+  if (length > 2)
+  {
+    if (!info[2].IsString())
+    {
+      Napi::TypeError::New(env, "name as String expected").ThrowAsJavaScriptException();
+      return;
+    }
+    name = info[2].As<Napi::String>().ToString();
+  }
+
+  if (length > 3)
+  {
+    if (!info[3].IsString())
+    {
+      Napi::TypeError::New(env, "msid as String expected").ThrowAsJavaScriptException();
+      return;
+    }
+    msid = info[3].As<Napi::String>().ToString();
+  }
+
+  if (length > 4)
+  {
+    if (!info[4].IsString())
+    {
+      Napi::TypeError::New(env, "trackID as String expected").ThrowAsJavaScriptException();
+      return;
+    }
+    trackID = info[4].As<Napi::String>().ToString();
+  }
+
+  mAudioPtr->replaceSSRC(oldSsrc, ssrc, name, msid, trackID);
+}
+
+Napi::Value AudioWrapper::hasSSRC(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 env.Null();
+  }
+
+  uint32_t ssrc = static_cast<uint32_t>(info[0].As<Napi::Number>().ToNumber());
+
+  return Napi::Boolean::New(env, mAudioPtr->hasSSRC(ssrc));
+}
+
+Napi::Value AudioWrapper::getSSRCs(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+
+  auto list = mAudioPtr->getSSRCs();
+
+  Napi::Uint32Array napiArr = Napi::Uint32Array::New(env, list.size());
+  for (size_t i = 0; i < list.size(); i++)
+    napiArr[i] = list[i];
+
+  return napiArr;
+}
+
+Napi::Value AudioWrapper::getCNameForSsrc(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 env.Null();
+  }
+
+  uint32_t ssrc = static_cast<uint32_t>(info[0].As<Napi::Number>().ToNumber());
+
+  std::optional<std::string> name = mAudioPtr->getCNameForSsrc(ssrc);
+
+  if (!name.has_value())
+    return env.Null();
+
+  return Napi::String::New(env, name.value());
+}
+
+void AudioWrapper::setBitrate(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;
+  }
+
+  unsigned int bitrate = static_cast<uint32_t>(info[0].As<Napi::Number>().ToNumber());
+  mAudioPtr->setBitrate(bitrate);
+}
+
+Napi::Value AudioWrapper::getBitrate(const Napi::CallbackInfo &info)
+{
+
+  return Napi::Number::New(info.Env(), mAudioPtr->bitrate());
+}
+
+Napi::Value AudioWrapper::hasPayloadType(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 env.Null();
+  }
+
+  int payloadType = static_cast<int>(info[0].As<Napi::Number>().ToNumber());
+
+  return Napi::Boolean::New(env, mAudioPtr->hasPayloadType(payloadType));
+}
+
+void AudioWrapper::addRTXCodec(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  if (length < 3 || !info[0].IsNumber() || !info[1].IsNumber() || !info[2].IsNumber())
+  {
+    Napi::TypeError::New(env, "We expect (Number,Number,Number) as param").ThrowAsJavaScriptException();
+    return;
+  }
+
+  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);
+}
+
+void AudioWrapper::addRTPMap(const Napi::CallbackInfo &info)
+{
+  // mAudioPtr->addRTPMap()
+}
+
+void AudioWrapper::parseSdpLine(const Napi::CallbackInfo &info)
+{
+  Napi::Env env = info.Env();
+  int length = info.Length();
+
+  if (length < 1 || !info[0].IsString())
+  {
+    Napi::TypeError::New(env, "We expect (String) as param").ThrowAsJavaScriptException();
+    return;
+  }
+
+  std::string line = info[0].As<Napi::String>().ToString();
+
+  mAudioPtr->parseSdpLine(line);
+}