react-native-webrtc-nitro 1.0.0

package/cpp/FFmpeg/Scaler.cpp

@@ -0,0 +1,34 @@
+#include "Scaler.hpp"
+
+using namespace FFmpeg;
+
+Scaler::~Scaler ()
+{
+    if (sws_ctx != nullptr)
+    {
+        sws_freeContext (sws_ctx);
+        sws_ctx = nullptr;
+    }
+}
+
+auto Scaler::scale (const Frame &frame, AVPixelFormat format, int width,
+                    int height) -> Frame
+{
+    std::lock_guard lock (mutex);
+    if (frame->format == format && frame->width == width
+        && frame->height == height)
+    {
+        return frame;
+    }
+
+    Frame dst (format, width, height, frame->pts);
+    sws_ctx = sws_getCachedContext (sws_ctx, frame->width, frame->height,
+                                    (AVPixelFormat)frame->format, dst->width,
+                                    dst->height, (AVPixelFormat)dst->format,
+                                    SWS_BILINEAR, nullptr, nullptr, nullptr);
+
+    int ret = sws_scale (sws_ctx, frame->data, frame->linesize, 0,
+                         frame->height, dst->data, dst->linesize);
+    checkError (ret, "sws_scale");
+    return dst;
+}

package/cpp/FFmpeg/Scaler.hpp

@@ -0,0 +1,18 @@
+#pragma once
+#include "Frame.hpp"
+
+namespace FFmpeg
+{
+    class Scaler
+    {
+      private:
+        std::recursive_mutex mutex;
+        SwsContext *sws_ctx = nullptr;
+
+      public:
+        ~Scaler ();
+
+        auto scale (const Frame &frame, AVPixelFormat format, int width,
+                    int height) -> Frame;
+    };
+} // namespace FFmpeg

package/cpp/FramePipe.cpp

@@ -0,0 +1,74 @@
+#include "FramePipe.hpp"
+#include <unordered_map>
+
+static std::recursive_mutex mutex;
+static int nextSubscriptionId = 1;
+
+struct Subscription
+{
+    std::vector<std::string> pipeIds;
+    FrameCallback onFrame;
+    CleanupCallback onCleanup;
+};
+
+std::unordered_map<int, Subscription> subscriptions;
+
+auto subscribe (const std::vector<std::string> &pipeIds,
+                const FrameCallback &onFrame, const CleanupCallback &onCleanup)
+    -> int
+{
+    std::lock_guard lock (mutex);
+    int subscriptionId = nextSubscriptionId++;
+    subscriptions[subscriptionId]
+        = Subscription{ pipeIds, onFrame, onCleanup };
+    return subscriptionId;
+}
+
+void unsubscribe (int subscriptionId)
+{
+    std::lock_guard lock (mutex);
+    // Make a copy to avoid iterator invalidation
+    auto subscriptionsCopy = subscriptions;
+    subscriptions.erase (subscriptionId);
+
+    for (auto &subscription : subscriptionsCopy)
+    {
+        if (subscription.first == subscriptionId)
+        {
+            if (subscription.second.onCleanup)
+            {
+                subscription.second.onCleanup (subscriptionId);
+            }
+        }
+    }
+}
+
+void publish (const std::string &pipeId, const FFmpeg::Frame &frame)
+{
+    if (pipeId.empty ())
+    {
+        return;
+    }
+    std::unordered_map<int, Subscription> subscriptionsCopy;
+    {
+        std::lock_guard lock (mutex);
+        // Make a copy to speed up
+        subscriptionsCopy = subscriptions;
+    }
+
+    for (auto &subscription : subscriptionsCopy)
+    {
+        for (const auto &pipeIdInSubscription : subscription.second.pipeIds)
+        {
+            if (pipeId == pipeIdInSubscription)
+            {
+                int subscriptionId = subscription.first;
+                if (subscription.second.onFrame)
+                {
+                    subscription.second.onFrame (pipeId, subscriptionId,
+                                                 frame);
+                }
+            }
+        }
+    }
+}

package/cpp/FramePipe.hpp

@@ -0,0 +1,14 @@
+#pragma once
+#include "FFmpeg.hpp"
+#include <functional>
+
+using FrameCallback
+    = std::function<void (const std::string &pipeId, int subscriptionId,
+                          const FFmpeg::Frame &frame)>;
+using CleanupCallback = std::function<void (int subscriptionId)>;
+
+auto subscribe (const std::vector<std::string> &pipeIds,
+                const FrameCallback &onFrame,
+                const CleanupCallback &onCleanup = {}) -> int;
+void unsubscribe (int subscriptionId);
+void publish (const std::string &pipeId, const FFmpeg::Frame &frame);

package/cpp/Hybrid/HybridMediaDevices.cpp

@@ -0,0 +1,82 @@
+#include "HybridMediaDevices.hpp"
+#include "MockCamera.hpp"
+#include "MockMicrophone.hpp"
+#include <NitroModules/HybridObjectRegistry.hpp>
+#include <NitroModules/Promise.hpp>
+
+using namespace margelo::nitro::webrtc;
+
+auto
+HybridMediaDevices::getMockMedia (const MediaStreamConstraints &constraints)
+    -> std::shared_ptr<Promise<std::shared_ptr<HybridMediaStreamSpec>>>
+{
+    auto hybridMediaStreams = std::make_shared<HybridMediaStream> ();
+    if (constraints.audio.value_or (false))
+    {
+        auto hybridAudioTrack
+            = std::make_shared<HybridMediaStreamTrack> ("audio");
+        hybridAudioTrack->mockMicrophone = std::make_shared<MockMicrophone> (
+            hybridAudioTrack->get_srcPipeId ());
+        hybridMediaStreams->addTrack (hybridAudioTrack);
+    }
+    if (constraints.video.value_or (false))
+    {
+        auto hybridVideoTrack
+            = std::make_shared<HybridMediaStreamTrack> ("video");
+        hybridVideoTrack->mockCamera = std::make_shared<MockCamera> (
+            hybridVideoTrack->get_srcPipeId ());
+        hybridMediaStreams->addTrack (hybridVideoTrack);
+    }
+    return Promise<std::shared_ptr<HybridMediaStreamSpec>>::resolved (
+        hybridMediaStreams);
+};
+
+auto
+HybridMediaDevices::getUserMedia (const MediaStreamConstraints &constraints)
+    -> std::shared_ptr<Promise<std::shared_ptr<HybridMediaStreamSpec>>>
+{
+    bool audio = constraints.audio.value_or (false);
+    bool video = constraints.video.value_or (false);
+
+    auto hybridMediaStreams = std::make_shared<HybridMediaStream> ();
+
+    if (audio)
+    {
+        auto microphoneObj
+            = HybridObjectRegistry::createHybridObject ("Microphone");
+        auto microphone
+            = std::dynamic_pointer_cast<HybridMicrophoneSpec> (microphoneObj);
+        if (!microphone)
+        {
+            throw std::runtime_error (
+                "Could not cast to HybridMicrophoneSpec");
+        }
+
+        auto hybridAudioTrack
+            = std::make_shared<HybridMediaStreamTrack> ("audio");
+        hybridAudioTrack->microphone = microphone;
+        hybridMediaStreams->addTrack (hybridAudioTrack);
+
+        microphone->open (hybridAudioTrack->get_srcPipeId ())->await ().get ();
+    }
+
+    if (video)
+    {
+        auto cameraObj = HybridObjectRegistry::createHybridObject ("Camera");
+        auto camera = std::dynamic_pointer_cast<HybridCameraSpec> (cameraObj);
+        if (!camera)
+        {
+            throw std::runtime_error ("Could not cast to HybridCameraSpec");
+        }
+
+        auto hybridVideoTrack
+            = std::make_shared<HybridMediaStreamTrack> ("video");
+        hybridVideoTrack->camera = camera;
+        hybridMediaStreams->addTrack (hybridVideoTrack);
+
+        camera->open (hybridVideoTrack->get_srcPipeId ())->await ().get ();
+    }
+
+    return Promise<std::shared_ptr<HybridMediaStreamSpec>>::resolved (
+        hybridMediaStreams);
+};

package/cpp/Hybrid/HybridMediaDevices.hpp

@@ -0,0 +1,23 @@
+#pragma once
+#include "HybridMediaDevicesSpec.hpp"
+#include "HybridMediaStream.hpp"
+#include "HybridMediaStreamTrack.hpp"
+
+namespace margelo::nitro::webrtc
+{
+    class HybridMediaDevices : public HybridMediaDevicesSpec
+    {
+      public:
+        HybridMediaDevices () : HybridObject (TAG), HybridMediaDevicesSpec ()
+        {
+        }
+
+        auto getMockMedia (const MediaStreamConstraints &constraints)
+            -> std::shared_ptr<
+                Promise<std::shared_ptr<HybridMediaStreamSpec>>> override;
+
+        auto getUserMedia (const MediaStreamConstraints &constraints)
+            -> std::shared_ptr<
+                Promise<std::shared_ptr<HybridMediaStreamSpec>>> override;
+    };
+} // namespace margelo::nitro::webrtc

package/cpp/Hybrid/HybridMediaStream.cpp

@@ -0,0 +1,63 @@
+#include "HybridMediaStream.hpp"
+
+using namespace margelo::nitro::webrtc;
+
+auto HybridMediaStream::getTracks ()
+    -> std::vector<std::shared_ptr<HybridMediaStreamTrackSpec>>
+{
+    std::vector<std::shared_ptr<HybridMediaStreamTrackSpec>>
+        hybridMediaStreamTrackSpecs;
+    hybridMediaStreamTrackSpecs.reserve (mediaStreamTrackMap.size ());
+
+    for (const auto &[_, track] : mediaStreamTrackMap)
+    {
+        hybridMediaStreamTrackSpecs.push_back (track);
+    }
+    return hybridMediaStreamTrackSpecs;
+};
+
+auto HybridMediaStream::getAudioTracks ()
+    -> std::vector<std::shared_ptr<HybridMediaStreamTrackSpec>>
+{
+    std::vector<std::shared_ptr<HybridMediaStreamTrackSpec>>
+        hybridMediaStreamTrackSpecs;
+    hybridMediaStreamTrackSpecs.reserve (mediaStreamTrackMap.size ());
+
+    for (const auto &[_, track] : mediaStreamTrackMap)
+    {
+        if (track->getKind () == "audio")
+        {
+            hybridMediaStreamTrackSpecs.push_back (track);
+        }
+    }
+    return hybridMediaStreamTrackSpecs;
+};
+
+auto HybridMediaStream::getVideoTracks ()
+    -> std::vector<std::shared_ptr<HybridMediaStreamTrackSpec>>
+{
+    std::vector<std::shared_ptr<HybridMediaStreamTrackSpec>>
+        hybridMediaStreamTrackSpecs;
+    hybridMediaStreamTrackSpecs.reserve (mediaStreamTrackMap.size ());
+
+    for (const auto &[_, track] : mediaStreamTrackMap)
+    {
+        if (track->getKind () == "video")
+        {
+            hybridMediaStreamTrackSpecs.push_back (track);
+        }
+    }
+    return hybridMediaStreamTrackSpecs;
+};
+
+void HybridMediaStream::addTrack (
+    const std::shared_ptr<HybridMediaStreamTrackSpec> &track)
+{
+    mediaStreamTrackMap[track->getId ()] = track;
+};
+
+void HybridMediaStream::removeTrack (
+    const std::shared_ptr<HybridMediaStreamTrackSpec> &track)
+{
+    mediaStreamTrackMap.erase (track->getId ());
+};

package/cpp/Hybrid/HybridMediaStream.hpp

@@ -0,0 +1,43 @@
+#pragma once
+#include "HybridMediaStreamSpec.hpp"
+#include "HybridMediaStreamTrack.hpp"
+
+namespace margelo::nitro::webrtc
+{
+    class HybridMediaStream : public HybridMediaStreamSpec
+    {
+      private:
+        const std::string id;
+        std::unordered_map<std::string,
+                           std::shared_ptr<HybridMediaStreamTrackSpec>>
+            mediaStreamTrackMap;
+
+      public:
+        HybridMediaStream ()
+            : HybridObject (TAG), HybridMediaStreamSpec (), id (uuidv4 ())
+        {
+        }
+
+        HybridMediaStream (std::string id)
+            : HybridObject (TAG), HybridMediaStreamSpec (), id (std::move (id))
+        {
+        }
+
+        auto getId () -> std::string override { return id; };
+
+        auto getTracks () -> std::vector<
+            std::shared_ptr<HybridMediaStreamTrackSpec>> override;
+
+        void addTrack (
+            const std::shared_ptr<HybridMediaStreamTrackSpec> &track) override;
+
+        void removeTrack (
+            const std::shared_ptr<HybridMediaStreamTrackSpec> &track) override;
+
+        auto getAudioTracks () -> std::vector<
+            std::shared_ptr<HybridMediaStreamTrackSpec>> override;
+
+        auto getVideoTracks () -> std::vector<
+            std::shared_ptr<HybridMediaStreamTrackSpec>> override;
+    };
+} // namespace margelo::nitro::webrtc

package/cpp/Hybrid/HybridMediaStreamTrack.cpp

@@ -0,0 +1,70 @@
+#include "HybridMediaStreamTrack.hpp"
+#include "FramePipe.hpp"
+#include <iomanip>
+#include <random>
+
+using namespace margelo::nitro::webrtc;
+
+auto margelo::nitro::webrtc::uuidv4 () -> std::string
+{
+    std::random_device rd;
+    std::mt19937 gen (rd ());
+    std::uniform_int_distribution<uint32_t> dis (0, 0xFFFFFFFF);
+
+    uint32_t d1 = dis (gen);
+    uint16_t d2 = dis (gen) & 0xFFFF;
+    uint16_t d3 = dis (gen) & 0xFFFF;
+    uint16_t d4 = dis (gen) & 0xFFFF;
+    uint64_t d5 = (((uint64_t)dis (gen) << 32) | dis (gen));
+
+    d3 = (d3 & 0x0FFF) | 0x4000;
+    d4 = (d4 & 0x3FFF) | 0x8000;
+
+    std::ostringstream oss;
+    oss << std::hex << std::setfill ('0') << std::nouppercase << std::setw (8)
+        << d1 << "-" << std::setw (4) << d2 << "-" << std::setw (4) << d3
+        << "-" << std::setw (4) << d4 << "-" << std::setw (12)
+        << (d5 & 0xFFFFFFFFFFFFULL);
+
+    return oss.str ();
+}
+
+void HybridMediaStreamTrack::enable ()
+{
+    if (getEnabled ())
+    {
+        return;
+    }
+    std::string dstPipeId = this->dstPipeId;
+    subscriptionId
+        = subscribe ({ srcPipeId }, [dstPipeId] (const std::string &, int,
+                                                 const FFmpeg::Frame &frame)
+                     { publish (dstPipeId, frame); });
+}
+
+void HybridMediaStreamTrack::disable ()
+{
+    if (!getEnabled ())
+    {
+        return;
+    }
+    unsubscribe (subscriptionId);
+    subscriptionId = -1;
+}
+
+auto HybridMediaStreamTrack::getEnabled () -> bool
+{
+    return subscriptionId > 0;
+}
+
+void HybridMediaStreamTrack::setEnabled (bool enabled)
+{
+    if (enabled)
+    {
+        this->enable ();
+    }
+    else
+    {
+        this->disable ();
+    }
+};

package/cpp/Hybrid/HybridMediaStreamTrack.hpp

@@ -0,0 +1,93 @@
+#pragma once
+#include "FramePipe.hpp"
+#include "HybridCameraSpec.hpp"
+#include "HybridMediaStreamTrackSpec.hpp"
+#include "HybridMicrophoneSpec.hpp"
+#include "MockCamera.hpp"
+#include "MockMicrophone.hpp"
+#include <thread>
+
+namespace margelo::nitro::webrtc
+{
+    auto uuidv4 () -> std::string;
+
+    class HybridMediaStreamTrack : public HybridMediaStreamTrackSpec
+    {
+      private:
+        const std::string kind;
+        const std::string id;
+        const std::string srcPipeId = uuidv4 ();
+        const std::string dstPipeId = uuidv4 ();
+        int subscriptionId = -1;
+        std::thread mockThread;
+        MediaStreamTrackState state = MediaStreamTrackState::LIVE;
+
+        void enable ();
+        void disable ();
+
+      public:
+        std::shared_ptr<MockMicrophone> mockMicrophone = nullptr;
+        std::shared_ptr<MockCamera> mockCamera = nullptr;
+        std::shared_ptr<HybridMicrophoneSpec> microphone = nullptr;
+        std::shared_ptr<HybridCameraSpec> camera = nullptr;
+
+        HybridMediaStreamTrack ()
+            : HybridObject (TAG), HybridMediaStreamTrackSpec ()
+        {
+            throw std::runtime_error (
+                "Uncaught TypeError: Illegal constructor");
+        }
+
+        HybridMediaStreamTrack (std::string kind)
+            : HybridObject (TAG), HybridMediaStreamTrackSpec (),
+              kind (std::move (kind)), id (uuidv4 ())
+        {
+            this->enable ();
+        }
+
+        HybridMediaStreamTrack (std::string kind, std::string id)
+            : HybridObject (TAG), HybridMediaStreamTrackSpec (),
+              kind (std::move (kind)), id (std::move (id))
+        {
+            this->enable ();
+        }
+
+        auto getId () -> std::string override { return id; };
+
+        auto getKind () -> std::string override { return kind; };
+
+        auto getReadyState () -> MediaStreamTrackState override
+        {
+            return state;
+        };
+
+        auto getEnabled () -> bool override;
+
+        void setEnabled (bool enabled) override;
+
+        auto get_srcPipeId () -> std::string override { return srcPipeId; };
+
+        auto get_dstPipeId () -> std::string override { return dstPipeId; };
+
+        void stop () override
+        {
+            state = MediaStreamTrackState::ENDED;
+            if (mockMicrophone)
+            {
+                mockMicrophone->dispose ();
+            }
+            if (mockCamera)
+            {
+                mockCamera->dispose ();
+            }
+            if (microphone)
+            {
+                microphone->dispose();
+            }
+            if (camera)
+            {
+                camera->dispose();
+            }
+        };
+    };
+} // namespace margelo::nitro::webrtc