mediasoup 3.20.0 → 3.20.2

package/worker/include/RTC/UdpSocket.hpp

@@ -3,6 +3,7 @@
 
 #include "common.hpp"
 #include "handles/UdpSocketHandle.hpp"
+#include "RTC/PortManager.hpp"
 #include "RTC/Transport.hpp"
 #include <string>
 
@@ -33,7 +34,7 @@ namespace RTC
 		  uint16_t minPort,
 		  uint16_t maxPort,
 		  RTC::Transport::SocketFlags& flags,
-		  uint64_t& portRangeHash);
+		  RTC::PortManager::PortRangeKey& portRangeKey);
 		~UdpSocket() override;
 
 		/* Pure virtual methods inherited from ::UdpSocketHandle. */
@@ -45,7 +46,7 @@ namespace RTC
 		// Passed by argument.
 		Listener* listener{ nullptr };
 		bool fixedPort{ false };
-		uint64_t portRangeHash{ 0u };
+		RTC::PortManager::PortRangeKey portRangeKey{};
 	};
 } // namespace RTC
 

package/worker/include/RTC/WebRtcServer.hpp

@@ -11,8 +11,7 @@
 #include "RTC/WebRtcTransport.hpp"
 #include "SharedInterface.hpp"
 #include <flatbuffers/flatbuffers.h>
-#include <absl/container/flat_hash_map.h>
-#include <absl/container/flat_hash_set.h>
+#include <ankerl/unordered_dense.h>
 #include <string>
 #include <vector>
 
@@ -116,11 +115,11 @@ namespace RTC
 		// Vector of UdpSockets and TcpServers in the user given order.
 		std::vector<UdpSocketOrTcpServer> udpSocketOrTcpServers;
 		// Set of WebRtcTransports.
-		absl::flat_hash_set<RTC::WebRtcTransport*> webRtcTransports;
+		ankerl::unordered_dense::set<RTC::WebRtcTransport*> webRtcTransports;
 		// Map of WebRtcTransports indexed by local ICE usernameFragment.
-		absl::flat_hash_map<std::string, RTC::WebRtcTransport*> mapLocalIceUsernameFragmentWebRtcTransport;
+		ankerl::unordered_dense::map<std::string, RTC::WebRtcTransport*> mapLocalIceUsernameFragmentWebRtcTransport;
 		// Map of WebRtcTransports indexed by TransportTuple.hash.
-		absl::flat_hash_map<uint64_t, RTC::WebRtcTransport*> mapTupleWebRtcTransport;
+		ankerl::unordered_dense::map<uint64_t, RTC::WebRtcTransport*> mapTupleWebRtcTransport;
 		// Whether the destructor has been called.
 		bool closing{ false };
 	};

package/worker/include/RTC/WebRtcTransport.hpp

@@ -158,8 +158,8 @@ namespace RTC
 		// Allocated by this.
 		RTC::ICE::IceServer* iceServer{ nullptr };
 		// Map of UdpSocket/TcpServer and local announced address (if any).
-		absl::flat_hash_map<RTC::UdpSocket*, std::string> udpSockets;
-		absl::flat_hash_map<RTC::TcpServer*, std::string> tcpServers;
+		ankerl::unordered_dense::map<RTC::UdpSocket*, std::string> udpSockets;
+		ankerl::unordered_dense::map<RTC::TcpServer*, std::string> tcpServers;
 		RTC::DtlsTransport* dtlsTransport{ nullptr };
 		RTC::SrtpSession* srtpRecvSession{ nullptr };
 		RTC::SrtpSession* srtpSendSession{ nullptr };

package/worker/include/Settings.hpp

@@ -4,7 +4,7 @@
 #include "common.hpp"
 #include "Channel/ChannelRequest.hpp"
 #include "LogLevel.hpp"
-#include <absl/container/flat_hash_map.h>
+#include <ankerl/unordered_dense.h>
 #include <string>
 #include <vector>
 
@@ -56,8 +56,8 @@ public:
 	static thread_local struct Configuration configuration;
 
 private:
-	static const absl::flat_hash_map<std::string, LogLevel> String2LogLevel;
-	static const absl::flat_hash_map<LogLevel, std::string> LogLevel2String;
+	static const ankerl::unordered_dense::map<std::string, LogLevel> String2LogLevel;
+	static const ankerl::unordered_dense::map<LogLevel, std::string> LogLevel2String;
 };
 
 #endif

package/worker/include/Worker.hpp

@@ -9,7 +9,7 @@
 #include "RTC/WebRtcServer.hpp"
 #include "SharedInterface.hpp"
 #include <flatbuffers/flatbuffer_builder.h>
-#include <absl/container/flat_hash_map.h>
+#include <ankerl/unordered_dense.h>
 #include <string>
 
 class Worker : public Channel::ChannelSocket::Listener,
@@ -54,8 +54,8 @@ private:
 	// Allocated by this.
 	SignalHandle* signalHandle{ nullptr };
 	SharedInterface* shared{ nullptr };
-	absl::flat_hash_map<std::string, RTC::WebRtcServer*> mapWebRtcServers;
-	absl::flat_hash_map<std::string, RTC::Router*> mapRouters;
+	ankerl::unordered_dense::map<std::string, RTC::WebRtcServer*> mapWebRtcServers;
+	ankerl::unordered_dense::map<std::string, RTC::Router*> mapRouters;
 	// Others.
 	bool closed{ false };
 };

package/worker/include/handles/TcpServerHandle.hpp

@@ -4,7 +4,7 @@
 #include "common.hpp"
 #include "handles/TcpConnectionHandle.hpp"
 #include <uv.h>
-#include <absl/container/flat_hash_set.h>
+#include <ankerl/unordered_dense.h>
 #include <string>
 
 class TcpServerHandle : public TcpConnectionHandle::Listener
@@ -72,7 +72,7 @@ private:
 	// Allocated by this (may be passed by argument).
 	uv_tcp_t* uvHandle{ nullptr };
 	// Others.
-	absl::flat_hash_set<TcpConnectionHandle*> connections;
+	ankerl::unordered_dense::set<TcpConnectionHandle*> connections;
 	bool closed{ false };
 };
 

package/worker/meson.build

@@ -314,6 +314,8 @@ abseil_cpp_proj = subproject(
   ],
 )
 
+ankerl_unordered_dense_dep = dependency('unordered_dense')
+
 flatbuffers_proj = subproject(
   'flatbuffers',
   default_options: [
@@ -326,24 +328,26 @@ subdir('fbs')
 
 # Add current build directory so libwebrtc has access to FBS folder.
 libwebrtc_include_directories = include_directories('include', 'fbs')
+
 subdir('deps/libwebrtc')
 
 dependencies = [
-  abseil_cpp_proj.get_variable('absl_container_dep'),
-  openssl_proj.get_variable('openssl_dep'),
   libuv_proj.get_variable('libuv_dep'),
+  openssl_proj.get_variable('openssl_dep'),
   libsrtp3_proj.get_variable('libsrtp3_dep'),
+  abseil_cpp_proj.get_variable('absl_container_dep'),
+  ankerl_unordered_dense_dep,
   flatbuffers_proj.get_variable('flatbuffers_dep'),
   flatbuffers_generator_dep,
   libwebrtc_dep,
 ]
 
 link_whole = [
-  abseil_cpp_proj.get_variable('absl_container_lib'),
+  libuv_proj.get_variable('libuv'),
   openssl_proj.get_variable('libcrypto_lib'),
   openssl_proj.get_variable('libssl_lib'),
-  libuv_proj.get_variable('libuv'),
   libsrtp3_proj.get_variable('libsrtp3'),
+  abseil_cpp_proj.get_variable('absl_container_lib'),
   flatbuffers_proj.get_variable('flatbuffers_lib'),
   libwebrtc,
 ]
@@ -447,6 +451,7 @@ test_sources = [
   'test/src/testHelpers.cpp',
   'test/src/RTC/TestKeyFrameRequestManager.cpp',
   'test/src/RTC/TestNackGenerator.cpp',
+  'test/src/RTC/TestPortManager.cpp',
   'test/src/RTC/TestRateCalculator.cpp',
   'test/src/RTC/TestRtpEncodingParameters.cpp',
   'test/src/RTC/TestSeqManager.cpp',

package/worker/mocks/include/Channel/MockChannelMessageRegistrator.hpp

@@ -4,8 +4,8 @@
 #include "Channel/ChannelMessageRegistratorInterface.hpp"
 // TODO: We should have a ChannelSocketInterface class instead.
 #include "Channel/ChannelSocket.hpp"
+#include <ankerl/unordered_dense.h>
 #include <string>
-#include <unordered_map>
 
 namespace mocks
 {
@@ -35,8 +35,9 @@ namespace mocks
 			  const std::string& id) override;
 
 		private:
-			std::unordered_map<std::string, ::Channel::ChannelSocket::RequestHandler*> mapChannelRequestHandlers;
-			std::unordered_map<std::string, ::Channel::ChannelSocket::NotificationHandler*>
+			ankerl::unordered_dense::map<std::string, ::Channel::ChannelSocket::RequestHandler*>
+			  mapChannelRequestHandlers;
+			ankerl::unordered_dense::map<std::string, ::Channel::ChannelSocket::NotificationHandler*>
 			  mapChannelNotificationHandlers;
 		};
 	} // namespace Channel

package/worker/src/Channel/ChannelNotification.cpp

@@ -4,13 +4,14 @@
 #include "Channel/ChannelNotification.hpp"
 #include "Logger.hpp"
 #include "MediaSoupErrors.hpp"
+#include <ankerl/unordered_dense.h>
 
 namespace Channel
 {
-	/* Class variables. */
+	/* Static. */
 
 	// clang-format off
-	const absl::flat_hash_map<FBS::Notification::Event, const char*> ChannelNotification::Event2String =
+	static const ankerl::unordered_dense::map<FBS::Notification::Event, const char*> Event2String =
 	{
 		{ FBS::Notification::Event::WORKER_CLOSE,        "worker.close"       },
 		{ FBS::Notification::Event::TRANSPORT_SEND_RTCP, "transport.sendRtcp" },
@@ -28,9 +29,9 @@ namespace Channel
 		this->data  = notification;
 		this->event = notification->event();
 
-		auto eventCStrIt = ChannelNotification::Event2String.find(this->event);
+		auto eventCStrIt = Event2String.find(this->event);
 
-		if (eventCStrIt == ChannelNotification::Event2String.end())
+		if (eventCStrIt == Event2String.end())
 		{
 			MS_THROW_ERROR("unknown event '%" PRIu8 "'", static_cast<uint8_t>(this->event));
 		}

package/worker/src/Channel/ChannelRequest.cpp

@@ -4,15 +4,14 @@
 #include "Channel/ChannelRequest.hpp"
 #include "Logger.hpp"
 #include "MediaSoupErrors.hpp"
+#include <ankerl/unordered_dense.h>
 
 namespace Channel
 {
-	/* Class variables. */
-
-	thread_local flatbuffers::FlatBufferBuilder ChannelRequest::bufferBuilder{};
+	/* Static. */
 
 	// clang-format off
-	const absl::flat_hash_map<FBS::Request::Method, const char*> ChannelRequest::Method2String =
+	static const ankerl::unordered_dense::map<FBS::Request::Method, const char*> Method2String =
 	{
 		{ FBS::Request::Method::WORKER_DUMP,                                    "worker.dump"                                },
 		{ FBS::Request::Method::WORKER_GET_RESOURCE_USAGE,                      "worker.getResourceUsage"                    },
@@ -85,6 +84,10 @@ namespace Channel
 	};
 	// clang-format on
 
+	/* Class variables. */
+
+	thread_local flatbuffers::FlatBufferBuilder ChannelRequest::bufferBuilder{};
+
 	/* Instance methods. */
 
 	/**
@@ -99,9 +102,9 @@ namespace Channel
 		this->id     = request->id();
 		this->method = request->method();
 
-		const auto methodCStrIt = ChannelRequest::Method2String.find(this->method);
+		const auto methodCStrIt = Method2String.find(this->method);
 
-		if (methodCStrIt == ChannelRequest::Method2String.end())
+		if (methodCStrIt == Method2String.end())
 		{
 			Error("unknown method");
 

package/worker/src/DepLibSRTP.cpp

@@ -16,7 +16,7 @@ static size_t GlobalInstances = 0;
 //   https://github.com/cisco/libsrtp/blob/main/include/srtp.h
 //
 // clang-format off
-const std::unordered_map<srtp_err_status_t, std::string> DepLibSRTP::ErrorCode2String =
+const ankerl::unordered_dense::map<srtp_err_status_t, std::string> DepLibSRTP::ErrorCode2String =
 {
 	{ srtp_err_status_ok,            "nothing to report" },
 	{ srtp_err_status_fail,          "unspecified failure" },

package/worker/src/RTC/AudioLevelObserver.cpp

@@ -5,8 +5,8 @@
 #include "Logger.hpp"
 #include "MediaSoupErrors.hpp"
 #include "RTC/RtpDictionaries.hpp"
-#include <absl/container/btree_map.h>
 #include <cmath> // std::lround()
+#include <map>   // std::multimap
 
 namespace RTC
 {
@@ -143,7 +143,7 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		absl::btree_multimap<int8_t, RTC::Producer*> mapDBovsProducer;
+		std::multimap<int8_t, RTC::Producer*> mapDBovsProducer;
 
 		for (auto& kv : this->mapProducerDBovs)
 		{

package/worker/src/RTC/DataConsumer.cpp

@@ -277,12 +277,22 @@ namespace RTC
 					  len);
 				}
 
+				// NOTE: Capturing `this` and `request` (by reference) is safe here because the
+				// callback is always invoked synchronously within this same call stack (never
+				// deferred).
 				const auto* cb = new onQueuedCallback(
-				  [&request](bool queued, bool sctpSendBufferFull)
+				  [this, &request](bool queued, bool sctpSendBufferFull)
 				  {
 					  if (queued)
 					  {
-						  request->Accept();
+						  uint32_t bufferedAmount{ 0 };
+
+						  this->listener->OnDataConsumerNeedBufferedAmount(this, bufferedAmount);
+
+						  auto responseOffset = FBS::DataConsumer::CreateGetBufferedAmountResponse(
+						    request->GetBufferBuilder(), bufferedAmount);
+
+						  request->Accept(FBS::Response::Body::DataConsumer_SendResponse, responseOffset);
 					  }
 					  else
 					  {
@@ -296,7 +306,7 @@ namespace RTC
 				  this->type == DataConsumer::Type::SCTP ? this->sctpStreamParameters.streamId : 0;
 
 				// NOTE: We are creating a copy of the data here, otherwise we cannot
-				// move the Message and pass its ownership to the SCTP stack.
+				// move the message and pass its ownership to the SCTP stack.
 				RTC::SCTP::Message message(streamId, body->ppid(), std::vector<uint8_t>(data, data + len));
 
 				SendMessage(std::move(message), emptySubchannels, std::nullopt, cb);

package/worker/src/RTC/DataProducer.cpp

@@ -233,7 +233,7 @@ namespace RTC
 				  this->type == DataProducer::Type::SCTP ? this->sctpStreamParameters.streamId : 0;
 
 				// NOTE: We are creating a copy of the data here, otherwise we cannot
-				// move the Message and pass its ownership to the SCTP stack.
+				// move the message and pass its ownership to the SCTP stack.
 				RTC::SCTP::Message message(streamId, body->ppid(), std::vector<uint8_t>(data, data + len));
 
 				ReceiveMessage(std::move(message), subchannels, requiredSubchannel);

package/worker/src/RTC/DtlsTransport.cpp

@@ -124,7 +124,7 @@ namespace RTC
 	thread_local EVP_PKEY* DtlsTransport::privateKey{ nullptr };
 	thread_local SSL_CTX* DtlsTransport::sslCtx{ nullptr };
 	thread_local uint8_t DtlsTransport::sslReadBuffer[SslReadBufferSize];
-	const absl::flat_hash_map<std::string, DtlsTransport::FingerprintAlgorithm>
+	const ankerl::unordered_dense::map<std::string, DtlsTransport::FingerprintAlgorithm>
 	  DtlsTransport::String2FingerprintAlgorithm = {
 		  { "sha-1",   DtlsTransport::FingerprintAlgorithm::SHA1   },
 		  { "sha-224", DtlsTransport::FingerprintAlgorithm::SHA224 },
@@ -132,7 +132,7 @@ namespace RTC
 		  { "sha-384", DtlsTransport::FingerprintAlgorithm::SHA384 },
 		  { "sha-512", DtlsTransport::FingerprintAlgorithm::SHA512 }
   };
-	const absl::flat_hash_map<DtlsTransport::FingerprintAlgorithm, std::string>
+	const ankerl::unordered_dense::map<DtlsTransport::FingerprintAlgorithm, std::string>
 	  DtlsTransport::FingerprintAlgorithm2String = {
 		  { DtlsTransport::FingerprintAlgorithm::SHA1,   "sha-1"   },
 		  { DtlsTransport::FingerprintAlgorithm::SHA224, "sha-224" },
@@ -140,7 +140,7 @@ namespace RTC
 		  { DtlsTransport::FingerprintAlgorithm::SHA384, "sha-384" },
 		  { DtlsTransport::FingerprintAlgorithm::SHA512, "sha-512" }
   };
-	const absl::flat_hash_map<std::string, DtlsTransport::Role> DtlsTransport::String2Role = {
+	const ankerl::unordered_dense::map<std::string, DtlsTransport::Role> DtlsTransport::String2Role = {
 		{ "auto",   DtlsTransport::Role::AUTO   },
 		{ "client", DtlsTransport::Role::CLIENT },
 		{ "server", DtlsTransport::Role::SERVER }

package/worker/src/RTC/ICE/IceServer.cpp

@@ -20,7 +20,7 @@ namespace RTC
 		/* Class variables. */
 
 		// clang-format off
-		std::unordered_map<IceServer::IceState, std::string> IceServer::iceStateToString =
+		ankerl::unordered_dense::map<IceServer::IceState, std::string> IceServer::iceStateToString =
 		{
 			{ IceServer::IceState::NEW,          "new"          },
 			{ IceServer::IceState::CONNECTED,    "connected"    },