node-datachannel 0.1.14-dev → 0.2.2

package/src/media-audio-wrapper.cpp

@@ -0,0 +1,457 @@
+#include "media-audio-wrapper.h"
+#include "media-direction.h"
+
+Napi::FunctionReference AudioWrapper::constructor;
+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),
+        });
+
+    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 > 1)
+    {
+        if (!info[0].IsString())
+        {
+            Napi::TypeError::New(env, "mid (String) expected").ThrowAsJavaScriptException();
+            return;
+        }
+        mid = info[0].As<Napi::String>().ToString();
+    }
+
+    // ootional
+    if (length > 2)
+    {
+        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].IsString())
+    {
+        Napi::TypeError::New(env, "We expect (String, String, String) 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();
+    std::string port = info[2].As<Napi::String>().ToString();
+
+    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;
+    }
+
+    int bitRate = static_cast<int>(info[0].As<Napi::Number>().ToNumber());
+
+    mAudioPtr->setBitrate(bitRate);
+}
+
+Napi::Value AudioWrapper::getBitrate(const Napi::CallbackInfo &info)
+{
+
+    return Napi::Number::New(info.Env(), mAudioPtr->getBitrate());
+}
+
+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;
+    }
+
+    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());
+
+    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);
+}

package/src/media-audio-wrapper.h

@@ -0,0 +1,54 @@
+#ifndef MEDIA_AUDIO_WRAPPER_H
+#define MEDIA_AUDIO_WRAPPER_H
+
+#include <unordered_set>
+
+#include <napi.h>
+#include <rtc/rtc.hpp>
+
+#include "thread-safe-callback.h"
+
+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/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/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/media-rtcpreceivingsession-wrapper.cpp

@@ -0,0 +1,63 @@
+#include "media-rtcpreceivingsession-wrapper.h"
+
+Napi::FunctionReference RtcpReceivingSessionWrapper::constructor;
+std::unordered_set<RtcpReceivingSessionWrapper *> RtcpReceivingSessionWrapper::instances;
+
+Napi::Object RtcpReceivingSessionWrapper::Init(Napi::Env env, Napi::Object exports)
+{
+    Napi::HandleScope scope(env);
+
+    Napi::Function func = Napi::ObjectWrap<RtcpReceivingSessionWrapper>::DefineClass(
+        env,
+        "RtcpReceivingSession",
+        {
+            Napi::ObjectWrap<RtcpReceivingSessionWrapper>::InstanceMethod("requestBitrate", &RtcpReceivingSessionWrapper::requestBitrate),
+            Napi::ObjectWrap<RtcpReceivingSessionWrapper>::InstanceMethod("requestKeyframe", &RtcpReceivingSessionWrapper::requestKeyframe),
+        });
+
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+
+    exports.Set("RtcpReceivingSession", func);
+    return exports;
+}
+
+RtcpReceivingSessionWrapper::RtcpReceivingSessionWrapper(const Napi::CallbackInfo &info) : Napi::ObjectWrap<RtcpReceivingSessionWrapper>(info)
+{
+    Napi::Env env = info.Env();
+    mSessionPtr = std::make_unique<rtc::RtcpReceivingSession>();
+    instances.insert(this);
+}
+
+RtcpReceivingSessionWrapper::~RtcpReceivingSessionWrapper()
+{
+    mSessionPtr.reset();
+    instances.erase(this);
+}
+
+std::shared_ptr<rtc::RtcpReceivingSession> RtcpReceivingSessionWrapper::getSessionInstance()
+{
+    return mSessionPtr;
+}
+
+void RtcpReceivingSessionWrapper::requestBitrate(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<unsigned int>(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-rtcpreceivingsession-wrapper.h

@@ -0,0 +1,36 @@
+#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:
+  static Napi::FunctionReference constructor;
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  RtcpReceivingSessionWrapper(const Napi::CallbackInfo &info);
+  ~RtcpReceivingSessionWrapper();
+  std::shared_ptr<rtc::RtcpReceivingSession> getSessionInstance();
+
+  // Functions
+  void requestBitrate(const Napi::CallbackInfo &info);
+  Napi::Value requestKeyframe(const Napi::CallbackInfo &info);
+
+  // Callbacks
+  
+
+private:
+  static std::unordered_set<RtcpReceivingSessionWrapper*> instances;
+  std::shared_ptr<rtc::RtcpReceivingSession> mSessionPtr = nullptr;
+};
+
+#endif // MEDIA_RTCPRECEIVINGSESSION_WRAPPER_H