react-native-webrtc-nitro 1.0.0

package/3rdparty/output/android/libdatachannel/x86/include/rtc/rtppacketizer.hpp

@@ -0,0 +1,105 @@
+/**
+ * Copyright (c) 2020 Filip Klembara (in2core)
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef RTC_RTP_PACKETIZER_H
+#define RTC_RTP_PACKETIZER_H
+
+#if RTC_ENABLE_MEDIA
+
+#include "mediahandler.hpp"
+#include "message.hpp"
+#include "rtppacketizationconfig.hpp"
+
+namespace rtc {
+
+/// RTP packetizer
+class RTC_CPP_EXPORT RtpPacketizer : public MediaHandler {
+public:
+	/// Default maximum fragment size (for video packetizers)
+	inline static const size_t DefaultMaxFragmentSize = RTC_DEFAULT_MAX_FRAGMENT_SIZE;
+
+	/// Clock rate for video in RTP
+	inline static const uint32_t VideoClockRate = 90 * 1000;
+
+	/// Constructs packetizer with given RTP configuration
+	/// @note RTP configuration is used in packetization process which may change some configuration
+	/// properties such as sequence number.
+	/// @param rtpConfig  RTP configuration
+	RtpPacketizer(shared_ptr<RtpPacketizationConfig> rtpConfig);
+	virtual ~RtpPacketizer();
+
+	virtual void media(const Description::Media &desc) override;
+	virtual void outgoing(message_vector &messages, const message_callback &send) override;
+
+	/// RTP packetization config
+	const shared_ptr<RtpPacketizationConfig> rtpConfig;
+
+protected:
+	/// Fragment data into payloads
+	/// Default implementation returns data as a single payload
+	/// @param message Input data
+	virtual std::vector<binary> fragment(binary data);
+
+	/// Creates an RTP packet for a payload
+	/// @note This function increases the sequence number.
+	/// @param payload RTP payload
+	/// @param mark Set marker flag in RTP packet if true
+	virtual message_ptr packetize(const binary &payload, bool mark);
+
+	// For backward compatibility, do not use
+	[[deprecated]] virtual message_ptr packetize(shared_ptr<binary> payload, bool mark);
+
+private:
+	static const auto RtpHeaderSize = 12;
+	static const auto RtpExtHeaderCvoSize = 8;
+};
+
+// Generic audio RTP packetizer
+template <uint32_t DEFAULT_CLOCK_RATE>
+class RTC_CPP_EXPORT AudioRtpPacketizer final : public RtpPacketizer {
+public:
+	inline static const uint32_t DefaultClockRate = DEFAULT_CLOCK_RATE;
+	inline static const uint32_t defaultClockRate [[deprecated("Use DefaultClockRate")]] =
+	    DEFAULT_CLOCK_RATE; // for backward compatibility
+
+	AudioRtpPacketizer(shared_ptr<RtpPacketizationConfig> rtpConfig)
+	    : RtpPacketizer(std::move(rtpConfig)) {}
+};
+
+// Audio RTP packetizers
+using OpusRtpPacketizer = AudioRtpPacketizer<48000>;
+using AACRtpPacketizer = AudioRtpPacketizer<48000>;
+using PCMARtpPacketizer = AudioRtpPacketizer<8000>;
+using PCMURtpPacketizer = AudioRtpPacketizer<8000>;
+using G722RtpPacketizer = AudioRtpPacketizer<8000>;
+
+// Dummy wrapper for backward compatibility, do not use
+class RTC_CPP_EXPORT PacketizationHandler final : public MediaHandler {
+public:
+	PacketizationHandler(shared_ptr<RtpPacketizer> packetizer)
+	    : mPacketizer(std::move(packetizer)) {}
+
+	inline void outgoing(message_vector &messages, const message_callback &send) {
+		return mPacketizer->outgoing(messages, send);
+	}
+
+private:
+	shared_ptr<RtpPacketizer> mPacketizer;
+};
+
+// Audio packetization handlers for backward compatibility, do not use
+using OpusPacketizationHandler [[deprecated("Add OpusRtpPacketizer directly")]] =
+    PacketizationHandler;
+using AACPacketizationHandler [[deprecated("Add AACRtpPacketizer directly")]] =
+    PacketizationHandler;
+
+} // namespace rtc
+
+#endif /* RTC_ENABLE_MEDIA */
+
+#endif /* RTC_RTP_PACKETIZER_H */

package/3rdparty/output/android/libdatachannel/x86/include/rtc/track.hpp

@@ -0,0 +1,65 @@
+/**
+ * Copyright (c) 2020 Paul-Louis Ageneau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef RTC_TRACK_H
+#define RTC_TRACK_H
+
+#include "channel.hpp"
+#include "common.hpp"
+#include "description.hpp"
+#include "mediahandler.hpp"
+
+namespace rtc {
+
+namespace impl {
+
+class Track;
+
+} // namespace impl
+
+class RTC_CPP_EXPORT Track final : private CheshireCat<impl::Track>, public Channel {
+public:
+	Track(impl_ptr<impl::Track> impl);
+	~Track() override;
+
+	string mid() const;
+	Description::Direction direction() const;
+	Description::Media description() const;
+
+	void setDescription(Description::Media description);
+
+	void close(void) override;
+	bool send(message_variant data) override;
+	bool send(const byte *data, size_t size) override;
+
+	bool isOpen(void) const override;
+	bool isClosed(void) const override;
+	size_t maxMessageSize() const override;
+
+	void sendFrame(binary data, FrameInfo info);
+	void sendFrame(const byte *data, size_t size, FrameInfo info);
+	void onFrame(std::function<void(binary data, FrameInfo info)> callback);
+
+	bool requestKeyframe();
+	bool requestBitrate(unsigned int bitrate);
+
+	void setMediaHandler(shared_ptr<MediaHandler> handler);
+	void chainMediaHandler(shared_ptr<MediaHandler> handler);
+	shared_ptr<MediaHandler> getMediaHandler();
+
+	// Deprecated, use setMediaHandler() and getMediaHandler()
+	inline void setRtcpHandler(shared_ptr<MediaHandler> handler) { setMediaHandler(handler); }
+	inline shared_ptr<MediaHandler> getRtcpHandler() { return getMediaHandler(); }
+
+private:
+	using CheshireCat<impl::Track>::impl;
+};
+
+} // namespace rtc
+
+#endif

package/3rdparty/output/android/libdatachannel/x86/include/rtc/utils.hpp

@@ -0,0 +1,159 @@
+/**
+ * Copyright (c) 2019-2021 Paul-Louis Ageneau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef RTC_UTILS_H
+#define RTC_UTILS_H
+
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <tuple>
+#include <utility>
+
+namespace rtc {
+
+// overloaded helper
+template <class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
+template <class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
+
+// weak_ptr bind helper
+template <typename F, typename T, typename... Args> auto weak_bind(F &&f, T *t, Args &&..._args) {
+	return [bound = std::bind(f, t, _args...), weak_this = t->weak_from_this()](auto &&...args) {
+		if (auto shared_this = weak_this.lock())
+			return bound(args...);
+		else
+			return static_cast<decltype(bound(args...))>(false);
+	};
+}
+
+// scope_guard helper
+class scope_guard final {
+public:
+	scope_guard(std::function<void()> func) : function(std::move(func)) {}
+	scope_guard(scope_guard &&other) = delete;
+	scope_guard(const scope_guard &) = delete;
+	void operator=(const scope_guard &) = delete;
+
+	~scope_guard() {
+		if (function)
+			function();
+	}
+
+private:
+	std::function<void()> function;
+};
+
+// callback with built-in synchronization
+template <typename... Args> class synchronized_callback {
+public:
+	synchronized_callback() = default;
+	synchronized_callback(synchronized_callback &&cb) { *this = std::move(cb); }
+	synchronized_callback(const synchronized_callback &cb) { *this = cb; }
+	synchronized_callback(std::function<void(Args...)> func) { *this = std::move(func); }
+	virtual ~synchronized_callback() { *this = nullptr; }
+
+	synchronized_callback &operator=(synchronized_callback &&cb) {
+		std::scoped_lock lock(mutex, cb.mutex);
+		set(std::exchange(cb.callback, nullptr));
+		return *this;
+	}
+
+	synchronized_callback &operator=(const synchronized_callback &cb) {
+		std::scoped_lock lock(mutex, cb.mutex);
+		set(cb.callback);
+		return *this;
+	}
+
+	synchronized_callback &operator=(std::function<void(Args...)> func) {
+		std::lock_guard lock(mutex);
+		set(std::move(func));
+		return *this;
+	}
+
+	bool operator()(Args... args) const {
+		std::lock_guard lock(mutex);
+		return call(std::move(args)...);
+	}
+
+	operator bool() const {
+		std::lock_guard lock(mutex);
+		return callback ? true : false;
+	}
+
+protected:
+	virtual void set(std::function<void(Args...)> func) { callback = std::move(func); }
+	virtual bool call(Args... args) const {
+		if (!callback)
+			return false;
+
+		callback(std::move(args)...);
+		return true;
+	}
+
+	std::function<void(Args...)> callback;
+	mutable std::recursive_mutex mutex;
+};
+
+// callback with built-in synchronization and replay of the last missed call
+template <typename... Args>
+class synchronized_stored_callback final : public synchronized_callback<Args...> {
+public:
+	template <typename... CArgs>
+	synchronized_stored_callback(CArgs &&...cargs)
+	    : synchronized_callback<Args...>(std::forward<CArgs>(cargs)...) {}
+	~synchronized_stored_callback() {}
+
+private:
+	void set(std::function<void(Args...)> func) {
+		synchronized_callback<Args...>::set(func);
+		if (func && stored) {
+			std::apply(func, std::move(*stored));
+			stored.reset();
+		}
+	}
+
+	bool call(Args... args) const {
+		if (!synchronized_callback<Args...>::call(args...))
+			stored.emplace(std::move(args)...);
+
+		return true;
+	}
+
+	mutable std::optional<std::tuple<Args...>> stored;
+};
+
+// pimpl base class
+template <typename T> using impl_ptr = std::shared_ptr<T>;
+template <typename T> class CheshireCat {
+public:
+	CheshireCat(impl_ptr<T> impl) : mImpl(std::move(impl)) {}
+	template <typename... Args>
+	CheshireCat(Args... args) : mImpl(std::make_shared<T>(std::forward<Args>(args)...)) {}
+	CheshireCat(CheshireCat<T> &&cc) { *this = std::move(cc); }
+	CheshireCat(const CheshireCat<T> &) = delete;
+
+	virtual ~CheshireCat() = default;
+
+	CheshireCat &operator=(CheshireCat<T> &&cc) {
+		mImpl = std::move(cc.mImpl);
+		return *this;
+	};
+	CheshireCat &operator=(const CheshireCat<T> &) = delete;
+
+protected:
+	impl_ptr<T> impl() { return mImpl; }
+	impl_ptr<const T> impl() const { return mImpl; }
+
+private:
+	impl_ptr<T> mImpl;
+};
+
+} // namespace rtc
+
+#endif

package/3rdparty/output/android/libdatachannel/x86/include/rtc/version.h

@@ -0,0 +1,9 @@
+#ifndef RTC_VERSION_H
+#define RTC_VERSION_H
+
+#define RTC_VERSION_MAJOR 0
+#define RTC_VERSION_MINOR 23
+#define RTC_VERSION_PATCH 1
+#define RTC_VERSION "0.23.1"
+
+#endif

package/3rdparty/output/android/libdatachannel/x86/include/rtc/websocket.hpp

@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2020-2021 Paul-Louis Ageneau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef RTC_WEBSOCKET_H
+#define RTC_WEBSOCKET_H
+
+#if RTC_ENABLE_WEBSOCKET
+
+#include "channel.hpp"
+#include "common.hpp"
+#include "configuration.hpp"
+
+namespace rtc {
+
+namespace impl {
+
+struct WebSocket;
+
+}
+
+class RTC_CPP_EXPORT WebSocket final : private CheshireCat<impl::WebSocket>, public Channel {
+public:
+	enum class State : int {
+		Connecting = 0,
+		Open = 1,
+		Closing = 2,
+		Closed = 3,
+	};
+
+	using Configuration = WebSocketConfiguration;
+
+	WebSocket();
+	WebSocket(Configuration config);
+	WebSocket(impl_ptr<impl::WebSocket> impl);
+	~WebSocket() override;
+
+	State readyState() const;
+
+	bool isOpen() const override;
+	bool isClosed() const override;
+	size_t maxMessageSize() const override;
+
+	void open(const string &url);
+	void close() override;
+	void forceClose();
+	bool send(const message_variant data) override;
+	bool send(const byte *data, size_t size) override;
+
+	optional<string> remoteAddress() const;
+	optional<string> path() const;
+
+private:
+	using CheshireCat<impl::WebSocket>::impl;
+};
+
+std::ostream &operator<<(std::ostream &out, WebSocket::State state);
+
+} // namespace rtc
+
+#endif
+
+#endif // RTC_WEBSOCKET_H

package/3rdparty/output/android/libdatachannel/x86/include/rtc/websocketserver.hpp

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2021 Paul-Louis Ageneau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef RTC_WEBSOCKETSERVER_H
+#define RTC_WEBSOCKETSERVER_H
+
+#if RTC_ENABLE_WEBSOCKET
+
+#include "common.hpp"
+#include "configuration.hpp"
+#include "websocket.hpp"
+
+namespace rtc {
+
+namespace impl {
+
+struct WebSocketServer;
+
+}
+
+class RTC_CPP_EXPORT WebSocketServer final : private CheshireCat<impl::WebSocketServer> {
+public:
+	using Configuration = WebSocketServerConfiguration;
+
+	WebSocketServer();
+	WebSocketServer(Configuration config);
+	~WebSocketServer();
+
+	void stop();
+
+	uint16_t port() const;
+
+	void onClient(std::function<void(shared_ptr<WebSocket>)> callback);
+
+private:
+	using CheshireCat<impl::WebSocketServer>::impl;
+};
+
+} // namespace rtc
+
+#endif
+
+#endif // RTC_WEBSOCKET_H

package/3rdparty/output/android/libdatachannel/x86_64/include/rtc/av1rtppacketizer.hpp

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2023 Paul-Louis Ageneau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef RTC_AV1_RTP_PACKETIZER_H
+#define RTC_AV1_RTP_PACKETIZER_H
+
+#if RTC_ENABLE_MEDIA
+
+#include "mediahandler.hpp"
+#include "nalunit.hpp"
+#include "rtppacketizer.hpp"
+
+namespace rtc {
+
+// RTP packetization of AV1 payload
+class RTC_CPP_EXPORT AV1RtpPacketizer final : public RtpPacketizer {
+public:
+	inline static const uint32_t ClockRate = VideoClockRate;
+	[[deprecated("Use ClockRate")]] inline static const uint32_t defaultClockRate = ClockRate;
+
+	// Define how OBUs are seperated in a AV1 Sample
+	enum class Packetization {
+		Obu = RTC_OBU_PACKETIZED_OBU,
+		TemporalUnit = RTC_OBU_PACKETIZED_TEMPORAL_UNIT,
+	};
+
+	// Constructs AV1 payload packetizer with given RTP configuration.
+	// @note RTP configuration is used in packetization process which may change some configuration
+	// properties such as sequence number.
+	AV1RtpPacketizer(Packetization packetization, shared_ptr<RtpPacketizationConfig> rtpConfig,
+	                 size_t maxFragmentSize = DefaultMaxFragmentSize);
+
+private:
+	static std::vector<binary> extractTemporalUnitObus(const binary &data);
+
+	std::vector<binary> fragment(binary data) override;
+	std::vector<binary> fragmentObu(const binary &data);
+
+	const Packetization mPacketization;
+	const size_t mMaxFragmentSize;
+
+	std::unique_ptr<binary> mSequenceHeader;
+};
+
+// For backward compatibility, do not use
+using AV1PacketizationHandler [[deprecated("Add AV1RtpPacketizer directly")]] = PacketizationHandler;
+
+} // namespace rtc
+
+#endif /* RTC_ENABLE_MEDIA */
+
+#endif /* RTC_AV1_RTP_PACKETIZER_H */

package/3rdparty/output/android/libdatachannel/x86_64/include/rtc/candidate.hpp

@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) 2019 Paul-Louis Ageneau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef RTC_CANDIDATE_H
+#define RTC_CANDIDATE_H
+
+#include "common.hpp"
+
+#include <string>
+
+namespace rtc {
+
+class RTC_CPP_EXPORT Candidate {
+public:
+	enum class Family { Unresolved, Ipv4, Ipv6 };
+	enum class Type { Unknown, Host, ServerReflexive, PeerReflexive, Relayed };
+	enum class TransportType { Unknown, Udp, TcpActive, TcpPassive, TcpSo, TcpUnknown };
+
+	Candidate();
+	Candidate(string candidate);
+	Candidate(string candidate, string mid);
+
+	void hintMid(string mid);
+	void changeAddress(string addr);
+	void changeAddress(string addr, uint16_t port);
+	void changeAddress(string addr, string service);
+
+	enum class ResolveMode { Simple, Lookup };
+	bool resolve(ResolveMode mode = ResolveMode::Simple);
+
+	Type type() const;
+	TransportType transportType() const;
+	uint32_t priority() const;
+	string candidate() const;
+	string mid() const;
+	operator string() const;
+
+	bool operator==(const Candidate &other) const;
+	bool operator!=(const Candidate &other) const;
+
+	bool isResolved() const;
+	Family family() const;
+	optional<string> address() const;
+	optional<uint16_t> port() const;
+
+private:
+	void parse(string candidate);
+
+	string mFoundation;
+	uint32_t mComponent, mPriority;
+	string mTypeString, mTransportString;
+	Type mType;
+	TransportType mTransportType;
+	string mNode, mService;
+	string mTail;
+
+	optional<string> mMid;
+
+	// Extracted on resolution
+	Family mFamily;
+	string mAddress;
+	uint16_t mPort;
+};
+
+RTC_CPP_EXPORT std::ostream &operator<<(std::ostream &out, const Candidate &candidate);
+RTC_CPP_EXPORT std::ostream &operator<<(std::ostream &out, const Candidate::Type &type);
+RTC_CPP_EXPORT std::ostream &operator<<(std::ostream &out,
+                                        const Candidate::TransportType &transportType);
+
+} // namespace rtc
+
+#endif

package/3rdparty/output/android/libdatachannel/x86_64/include/rtc/channel.hpp

@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) 2019-2021 Paul-Louis Ageneau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef RTC_CHANNEL_H
+#define RTC_CHANNEL_H
+
+#include "common.hpp"
+
+#include <atomic>
+#include <functional>
+
+namespace rtc {
+
+namespace impl {
+struct Channel;
+}
+
+class RTC_CPP_EXPORT Channel : private CheshireCat<impl::Channel> {
+public:
+	virtual ~Channel();
+
+	virtual void close() = 0;
+	virtual bool send(message_variant data) = 0; // returns false if buffered
+	virtual bool send(const byte *data, size_t size) = 0;
+
+	virtual bool isOpen() const = 0;
+	virtual bool isClosed() const = 0;
+	virtual size_t maxMessageSize() const; // max message size in a call to send
+	virtual size_t bufferedAmount() const; // total size buffered to send
+
+	void onOpen(std::function<void()> callback);
+	void onClosed(std::function<void()> callback);
+	void onError(std::function<void(string error)> callback);
+
+	void onMessage(std::function<void(message_variant data)> callback);
+	void onMessage(std::function<void(binary data)> binaryCallback,
+	               std::function<void(string data)> stringCallback);
+
+	void onBufferedAmountLow(std::function<void()> callback);
+	void setBufferedAmountLowThreshold(size_t amount);
+
+	void resetCallbacks();
+
+	// Extended API
+	optional<message_variant> receive(); // only if onMessage unset
+	optional<message_variant> peek();    // only if onMessage unset
+	size_t availableAmount() const;      // total size available to receive
+	void onAvailable(std::function<void()> callback);
+
+protected:
+	Channel(impl_ptr<impl::Channel> impl);
+};
+
+} // namespace rtc
+
+#endif // RTC_CHANNEL_H