mediasoup 3.20.0 → 3.20.2

package/worker/include/RTC/ICE/StunPacket.hpp

@@ -4,8 +4,8 @@
 #include "common.hpp"
 #include "RTC/Serializable.hpp"
 #include "Utils.hpp"
+#include <ankerl/unordered_dense.h>
 #include <string_view>
-#include <unordered_map>
 
 namespace RTC
 {
@@ -58,10 +58,10 @@ namespace RTC
 			/**
 			 * STUN Attributes.
 			 *
-			 * After the STUN Message Header are zero or more Attributes. Each
-			 * Attribute MUST be TLV encoded, with a 16-bit type, 16-bit length, and
-			 * value. Each STUN Attribute MUST end on a 32-bit boundary.  All fields
-			 * in an Attribute are transmitted most significant bit first.
+			 * After the STUN message header are zero or more attributes. Each
+			 * attribute MUST be TLV encoded, with a 16-bit type, 16-bit length, and
+			 * value. Each STUN attribute MUST end on a 32-bit boundary.  All fields
+			 * in an attribute are transmitted most significant bit first.
 			 *
 			 *  0                   1                   2                   3
 			 *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
@@ -145,7 +145,7 @@ namespace RTC
 				 */
 				uint16_t len;
 				/**
-				 * Offset of the Attribute from the start of the Attributes.
+				 * Offset of the attribute from the start of the attributes.
 				 */
 				size_t offset;
 			};
@@ -161,23 +161,23 @@ namespace RTC
 			static const size_t FingerprintAttributeLength{ 4 };
 
 			/**
-			 * Whether given buffer could be a valid STUN Packet.
+			 * Whether given buffer could be a valid STUN packet.
 			 */
 			static bool IsStun(const uint8_t* buffer, size_t bufferLength);
 
 			/**
-			 * Parse a STUN Packet.
+			 * Parse a STUN packet.
 			 *
 			 * @remarks
-			 * - `bufferLength` must be the exact length of the STUN Packet.
+			 * - `bufferLength` must be the exact length of the STUN packet.
 			 */
 			static StunPacket* Parse(const uint8_t* buffer, size_t bufferLength);
 
 			/**
-			 * Create a STUN Packet.
+			 * Create a STUN packet.
 			 *
 			 * @remarks
-			 * - `bufferLength` must be the exact length of the STUN Packet.
+			 * - `bufferLength` must be the exact length of the STUN packet.
 			 * - If `transactionId` is not given then a random Transaction ID is
 			 *   generated.
 			 */
@@ -196,7 +196,7 @@ namespace RTC
 
 		private:
 			/**
-			 * Constructor is private because we only want to create STUN Packet
+			 * Constructor is private because we only want to create STUN packet
 			 * instances via Parse() and Factory().
 			 */
 			StunPacket(uint8_t* buffer, size_t bufferLength);
@@ -366,8 +366,8 @@ namespace RTC
 			StunPacket::AuthenticationResult CheckAuthentication(std::string_view password) const;
 
 			/**
-			 * Whether the STUN Packet is protected, meaning that it has
-			 * MESSAGE-INTEGRITY and/or FINGERPRINT Attributes.
+			 * Whether the STUN packet is protected, meaning that it has
+			 * MESSAGE-INTEGRITY and/or FINGERPRINT attributes.
 			 */
 			bool IsProtected() const
 			{
@@ -377,17 +377,17 @@ namespace RTC
 			}
 
 			/**
-			 * Adds MESSAGE-INTEGRITY and FINGERPRINT to the STUN Packet.
+			 * Adds MESSAGE-INTEGRITY and FINGERPRINT to the STUN packet.
 			 *
 			 * @remarks
 			 * - MESSAGE-INTEGRITY is only added if given `password` is not empty.
-			 * - The application MUST NOT add more Attributes into the STUN Packet
-			 *   and MUST NOT modify any field of the STUN Packet after calling
+			 * - The application MUST NOT add more attributes into the STUN packet
+			 *   and MUST NOT modify any field of the STUN packet after calling
 			 *   this method.
 			 *
 			 * @throw MediaSoupTypeError - If there is no enough space in the buffer.
-			 * @throw MediaSoupError - If the STUN Packet already has MESSAGE-INTEGRITY
-			 *   or FINGERPRINT Attributes.
+			 * @throw MediaSoupError - If the STUN packet already has MESSAGE-INTEGRITY
+			 *   or FINGERPRINT attributes.
 			 */
 			void Protect(const std::string_view password);
 
@@ -396,15 +396,15 @@ namespace RTC
 			/**
 			 * Creates a STUN success response for the current STUN request.
 			 *
-			 * @throw MediaSoupError - If the STUN Packet is not a STUN request.
+			 * @throw MediaSoupError - If the STUN packet is not a STUN request.
 			 */
 			StunPacket* CreateSuccessResponse(uint8_t* buffer, size_t bufferLength) const;
 
 			/**
 			 * Creates a STUN error response for the current STUN request. It uses
-			 * given `errorCode` and `reasonPhrase` to add a ERROR-CODE Attribute.
+			 * given `errorCode` and `reasonPhrase` to add a ERROR-CODE attribute.
 			 *
-			 * @throw MediaSoupError - If the STUN Packet is not a STUN request.
+			 * @throw MediaSoupError - If the STUN packet is not a STUN request.
 			 */
 			StunPacket* CreateErrorResponse(
 			  uint8_t* buffer,
@@ -444,8 +444,8 @@ namespace RTC
 			}
 
 			/**
-			 * Validates whether the STUN Packet is valid. It also stores internal
-			 * offsets pointing to relevant STUN Attributes if `storeAttributes` is
+			 * Validates whether the STUN packet is valid. It also stores internal
+			 * offsets pointing to relevant STUN attributes if `storeAttributes` is
 			 * `true`.
 			 */
 #ifdef MS_TEST
@@ -457,26 +457,26 @@ namespace RTC
 #endif
 
 			/**
-			 * Parses Attributes. Returns `true` if they are valid. It also stores
-			 * internal containers holding Attributes if `storeAttributes` is `true`.
+			 * Parses attributes. Returns `true` if they are valid. It also stores
+			 * internal containers holding attributes if `storeAttributes` is `true`.
 			 */
 			bool ParseAttributes(bool storeAttributes);
 
 			/**
-			 * Stores the parsed Attribute data into the map of Attributes.
+			 * Stores the parsed attribute data into the map of attributes.
 			 *
-			 * @return `true` if the Attribute was stored and `false` if it couldn't
-			 *   be stored because there was already an Attribute with same type in
+			 * @return `true` if the attribute was stored and `false` if it couldn't
+			 *   be stored because there was already an attribute with same type in
 			 *   the map.
 			 */
 			bool StoreParsedAttribute(StunPacket::AttributeType type, uint16_t len, size_t offset);
 
 			/**
-			 * Stores a new Attribute data into the map of Attributes.
+			 * Stores a new attribute data into the map of attributes.
 			 *
 			 * @throw MediaSoupError - If there is not enough space in the buffer for
-			 *   the new Attribute or if the Attribute couldn't be stored because
-			 *   there was already an Attribute with same type in the map.
+			 *   the new attribute or if the attribute couldn't be stored because
+			 *   there was already an attribute with same type in the map.
 			 */
 			void StoreNewAttribute(StunPacket::AttributeType type, const void* data, uint16_t len);
 
@@ -532,8 +532,8 @@ namespace RTC
 		private:
 			StunPacket::Class klass{ StunPacket::Class::UNSET };
 			StunPacket::Method method{ StunPacket::Method::UNSET };
-			// Map of STUN Attributes indexed by Attribute type.
-			std::unordered_map<StunPacket::AttributeType, StunPacket::Attribute> attributes;
+			// Map of STUN attributes indexed by attribute type.
+			ankerl::unordered_dense::map<StunPacket::AttributeType, StunPacket::Attribute> attributes;
 		};
 	} // namespace ICE
 } // namespace RTC

package/worker/include/RTC/KeyFrameRequestManager.hpp

@@ -3,7 +3,7 @@
 
 #include "handles/TimerHandleInterface.hpp"
 #include "SharedInterface.hpp"
-#include <absl/container/flat_hash_map.h>
+#include <ankerl/unordered_dense.h>
 
 namespace RTC
 {
@@ -125,8 +125,8 @@ namespace RTC
 		Listener* listener{ nullptr };
 		SharedInterface* shared{ nullptr };
 		uint32_t keyFrameRequestDelay{ 0u }; // 0 means disabled.
-		absl::flat_hash_map<uint32_t, PendingKeyFrameInfo*> mapSsrcPendingKeyFrameInfo;
-		absl::flat_hash_map<uint32_t, KeyFrameRequestDelayer*> mapSsrcKeyFrameRequestDelayer;
+		ankerl::unordered_dense::map<uint32_t, PendingKeyFrameInfo*> mapSsrcPendingKeyFrameInfo;
+		ankerl::unordered_dense::map<uint32_t, KeyFrameRequestDelayer*> mapSsrcKeyFrameRequestDelayer;
 	};
 } // namespace RTC
 

package/worker/include/RTC/Parameters.hpp

@@ -3,7 +3,7 @@
 
 #include "common.hpp"
 #include "FBS/rtpParameters.h"
-#include <absl/container/flat_hash_map.h>
+#include <ankerl/unordered_dense.h>
 #include <string>
 #include <vector>
 
@@ -78,7 +78,7 @@ namespace RTC
 		const std::vector<int32_t>& GetArrayOfIntegers(const std::string& key) const;
 
 	private:
-		absl::flat_hash_map<std::string, Value> mapKeyValues;
+		ankerl::unordered_dense::map<std::string, Value> mapKeyValues;
 	};
 } // namespace RTC
 

package/worker/include/RTC/PipeConsumer.hpp

@@ -3,6 +3,7 @@
 
 #include "RTC/Consumer.hpp"
 #include "RTC/SeqManager.hpp"
+#include <ankerl/unordered_dense.h>
 #include <map>
 
 namespace RTC
@@ -77,14 +78,14 @@ namespace RTC
 		// Allocated by this.
 		std::vector<RTC::RTP::RtpStreamSend*> rtpStreams;
 		// Others.
-		absl::flat_hash_map<uint32_t, uint32_t> mapMappedSsrcSsrc;
-		absl::flat_hash_map<uint32_t, RTC::RTP::RtpStreamSend*> mapSsrcRtpStream;
+		ankerl::unordered_dense::map<uint32_t, uint32_t> mapMappedSsrcSsrc;
+		ankerl::unordered_dense::map<uint32_t, RTC::RTP::RtpStreamSend*> mapSsrcRtpStream;
 		bool keyFrameSupported{ false };
-		absl::flat_hash_map<RTC::RTP::RtpStreamSend*, bool> mapRtpStreamSyncRequired;
-		absl::flat_hash_map<RTC::RTP::RtpStreamSend*, RTC::SeqManager<uint16_t>> mapRtpStreamRtpSeqManager;
+		ankerl::unordered_dense::map<RTC::RTP::RtpStreamSend*, bool> mapRtpStreamSyncRequired;
+		ankerl::unordered_dense::map<RTC::RTP::RtpStreamSend*, RTC::SeqManager<uint16_t>> mapRtpStreamRtpSeqManager;
 		// Buffers to store packets that arrive earlier than the first packet of the
 		// video key frame.
-		absl::flat_hash_map<
+		ankerl::unordered_dense::map<
 		  RTC::RTP::RtpStreamSend*,
 		  std::map<uint16_t, RTC::RTP::SharedPacket, RTC::SeqManager<uint16_t>::SeqLowerThan>>
 		  mapRtpStreamTargetLayerRetransmissionBuffer;

package/worker/include/RTC/PlainTransport.hpp

@@ -7,7 +7,6 @@
 #include "RTC/TransportTuple.hpp"
 #include "RTC/UdpSocket.hpp"
 #include "SharedInterface.hpp"
-#include <absl/container/flat_hash_map.h>
 
 namespace RTC
 {

package/worker/include/RTC/PortManager.hpp

@@ -3,8 +3,10 @@
 
 #include "common.hpp"
 #include "RTC/Transport.hpp"
+#include "Utils.hpp"
 #include <uv.h>
-#include <absl/container/flat_hash_map.h>
+#include <ankerl/unordered_dense.h>
+#include <ostream>
 #include <string>
 #include <vector>
 
@@ -12,13 +14,75 @@ namespace RTC
 {
 	class PortManager
 	{
-	private:
+	public:
 		enum class Protocol : uint8_t
 		{
 			UDP = 1,
 			TCP
 		};
 
+		/**
+		 * Opaque-ish key identifying one (protocol, bind address, port range)
+		 * tuple. Issued by Bind*() and consumed by Unbind(). Callers store it as
+		 * an opaque token; equality and hashing are exact-tuple based, so distinct
+		 * tuples never collide regardless of how close their numeric
+		 * representations are.
+		 */
+		class PortRangeKey
+		{
+		private:
+			friend class PortManager;
+			friend struct PortRangeKeyHash;
+
+		public:
+			PortRangeKey() = default;
+			PortRangeKey(
+			  Protocol protocol, const sockaddr_storage& bindAddr, uint16_t minPort, uint16_t maxPort);
+
+			bool operator==(const PortRangeKey& other) const noexcept;
+			bool operator!=(const PortRangeKey& other) const noexcept
+			{
+				return !(*this == other);
+			}
+
+		public:
+			Protocol GetProtocol() const
+			{
+				return this->protocol;
+			}
+			const sockaddr_storage& GetSockaddrStorage() const
+			{
+				return this->bindAddr;
+			}
+			uint16_t GetMinPort() const
+			{
+				return this->minPort;
+			}
+			uint16_t GetMaxPort() const
+			{
+				return this->maxPort;
+			}
+
+		private:
+			Protocol protocol{ Protocol::UDP };
+			sockaddr_storage bindAddr{};
+			uint16_t minPort{ 0u };
+			uint16_t maxPort{ 0u };
+		};
+
+		struct PortRangeKeyHash
+		{
+			/**
+			 * Hash function. Uses ankerl::unordered_dense per-field hashes combined
+			 * with the standard boost-style `hash_combine` seed mixer. We deliberately
+			 * do NOT hash the raw `sockaddr_storage` bytes (padding is
+			 * caller-controlled and would cause structurally-equal keys to hash
+			 * differently); instead we hash the same fields that `operator==`
+			 * inspects.
+			 */
+			size_t operator()(const PortRangeKey& key) const noexcept;
+		};
+
 	private:
 		struct PortRange
 		{
@@ -42,9 +106,9 @@ namespace RTC
 		  uint16_t minPort,
 		  uint16_t maxPort,
 		  RTC::Transport::SocketFlags& flags,
-		  uint64_t& hash)
+		  PortRangeKey& key)
 		{
-			return reinterpret_cast<uv_udp_t*>(Bind(Protocol::UDP, ip, minPort, maxPort, flags, hash));
+			return reinterpret_cast<uv_udp_t*>(Bind(Protocol::UDP, ip, minPort, maxPort, flags, key));
 		}
 		static uv_tcp_t* BindTcp(std::string& ip, uint16_t port, RTC::Transport::SocketFlags& flags)
 		{
@@ -55,11 +119,11 @@ namespace RTC
 		  uint16_t minPort,
 		  uint16_t maxPort,
 		  RTC::Transport::SocketFlags& flags,
-		  uint64_t& hash)
+		  PortRangeKey& key)
 		{
-			return reinterpret_cast<uv_tcp_t*>(Bind(Protocol::TCP, ip, minPort, maxPort, flags, hash));
+			return reinterpret_cast<uv_tcp_t*>(Bind(Protocol::TCP, ip, minPort, maxPort, flags, key));
 		}
-		static void Unbind(uint64_t hash, uint16_t port);
+		static void Unbind(const PortRangeKey& key, uint16_t port);
 		void Dump(int indentation = 0) const;
 
 	private:
@@ -71,15 +135,31 @@ namespace RTC
 		  uint16_t minPort,
 		  uint16_t maxPort,
 		  RTC::Transport::SocketFlags& flags,
-		  uint64_t& hash);
-		static uint64_t GeneratePortRangeHash(
-		  Protocol protocol, sockaddr_storage* bindAddr, uint16_t minPort, uint16_t maxPort);
-		static PortRange& GetOrCreatePortRange(uint64_t hash, uint16_t minPort, uint16_t maxPort);
+		  PortRangeKey& key);
+		static PortRange& GetOrCreatePortRange(const PortRangeKey& key, uint16_t minPort, uint16_t maxPort);
 		static uint8_t ConvertSocketFlags(RTC::Transport::SocketFlags& flags, Protocol protocol, int family);
 
 	private:
-		static thread_local absl::flat_hash_map<uint64_t, PortRange> mapPortRanges;
+		static thread_local ankerl::unordered_dense::map<PortRangeKey, PortRange, PortRangeKeyHash> mapPortRanges;
 	};
+
+	/**
+	 * For Catch2 to print it nicely.
+	 */
+	inline std::ostream& operator<<(std::ostream& os, const PortManager::PortRangeKey& k)
+	{
+		const std::string protocolStr = (k.GetProtocol() == PortManager::Protocol::UDP) ? "udp" : "tcp";
+
+		int family;
+		uint16_t port;
+		std::string ip;
+		auto* storage = const_cast<sockaddr_storage*>(std::addressof(k.GetSockaddrStorage()));
+
+		Utils::IP::GetAddressInfo(reinterpret_cast<sockaddr*>(storage), family, ip, port);
+
+		return os << "{protocol:" << protocolStr << ", family:" << family << ", ip:" << ip
+		          << ", minPort:" << k.GetMinPort() << ", maxPort:" << k.GetMaxPort() << "}";
+	}
 } // namespace RTC
 
 #endif

package/worker/include/RTC/Producer.hpp

@@ -14,6 +14,7 @@
 #include "RTC/RTP/RtpStreamRecv.hpp"
 #include "RTC/RtpDictionaries.hpp"
 #include "SharedInterface.hpp"
+#include <ankerl/unordered_dense.h>
 #include <string>
 #include <vector>
 
@@ -61,7 +62,7 @@ namespace RTC
 	private:
 		struct RtpMapping
 		{
-			absl::flat_hash_map<uint8_t, uint8_t> codecs;
+			ankerl::unordered_dense::map<uint8_t, uint8_t> codecs;
 			std::vector<RtpEncodingMapping> encodings;
 		};
 
@@ -125,7 +126,7 @@ namespace RTC
 		{
 			return this->paused;
 		}
-		const absl::flat_hash_map<RTC::RTP::RtpStreamRecv*, uint32_t>& GetRtpStreams()
+		const ankerl::unordered_dense::map<RTC::RTP::RtpStreamRecv*, uint32_t>& GetRtpStreams()
 		{
 			return this->mapRtpStreamMappedSsrc;
 		}
@@ -182,7 +183,7 @@ namespace RTC
 		SharedInterface* shared{ nullptr };
 		RTC::Producer::Listener* listener{ nullptr };
 		// Allocated by this.
-		absl::flat_hash_map<uint32_t, RTC::RTP::RtpStreamRecv*> mapSsrcRtpStream;
+		ankerl::unordered_dense::map<uint32_t, RTC::RTP::RtpStreamRecv*> mapSsrcRtpStream;
 		RTC::KeyFrameRequestManager* keyFrameRequestManager{ nullptr };
 		// Others.
 		RTC::Media::Kind kind;
@@ -191,9 +192,9 @@ namespace RTC
 		struct RtpMapping rtpMapping;
 		std::vector<RTC::RTP::RtpStreamRecv*> rtpStreamByEncodingIdx;
 		std::vector<uint8_t> rtpStreamScores;
-		absl::flat_hash_map<uint32_t, RTC::RTP::RtpStreamRecv*> mapRtxSsrcRtpStream;
-		absl::flat_hash_map<RTC::RTP::RtpStreamRecv*, uint32_t> mapRtpStreamMappedSsrc;
-		absl::flat_hash_map<uint32_t, uint32_t> mapMappedSsrcSsrc;
+		ankerl::unordered_dense::map<uint32_t, RTC::RTP::RtpStreamRecv*> mapRtxSsrcRtpStream;
+		ankerl::unordered_dense::map<RTC::RTP::RtpStreamRecv*, uint32_t> mapRtpStreamMappedSsrc;
+		ankerl::unordered_dense::map<uint32_t, uint32_t> mapMappedSsrcSsrc;
 		struct RTC::RTP::HeaderExtensionIds rtpHeaderExtensionIds;
 		bool paused{ false };
 		bool enableMediasoupPacketIdHeaderExtension{ false };

package/worker/include/RTC/RTCP/Feedback.hpp

@@ -3,7 +3,6 @@
 
 #include "common.hpp"
 #include "RTC/RTCP/Packet.hpp"
-#include <absl/container/flat_hash_map.h>
 
 namespace RTC
 {
@@ -32,7 +31,7 @@ namespace RTC
 			static const std::string& MessageTypeToString(typename T::MessageType type);
 
 		private:
-			static const absl::flat_hash_map<typename T::MessageType, std::string> MessageType2String;
+			static const ankerl::unordered_dense::map<typename T::MessageType, std::string> MessageType2String;
 
 		public:
 			typename T::MessageType GetMessageType() const

package/worker/include/RTC/RTCP/FeedbackRtpTransport.hpp

@@ -5,7 +5,7 @@
 #include "RTC/RTCP/Feedback.hpp"
 #include <vector>
 
-/* RTP Extensions for Transport-wide Congestion Control
+/* RTP extensions for Transport-wide Congestion Control
  * draft-holmer-rmcat-transport-wide-cc-extensions-01
 
    0               1               2               3
@@ -201,7 +201,7 @@ namespace RTC
 			static FeedbackRtpTransportPacket* Parse(const uint8_t* data, size_t len);
 
 		private:
-			static const absl::flat_hash_map<Status, std::string> Status2String;
+			static const ankerl::unordered_dense::map<Status, std::string> Status2String;
 
 		public:
 			FeedbackRtpTransportPacket(uint32_t senderSsrc, uint32_t mediaSsrc)

package/worker/include/RTC/RTCP/Packet.hpp

@@ -2,7 +2,7 @@
 #define MS_RTC_RTCP_PACKET_HPP
 
 #include "common.hpp"
-#include <absl/container/flat_hash_map.h>
+#include <ankerl/unordered_dense.h>
 #include <string>
 
 namespace RTC
@@ -77,7 +77,7 @@ namespace RTC
 			static const std::string& TypeToString(Type type);
 
 		private:
-			static const absl::flat_hash_map<Type, std::string> Type2String;
+			static const ankerl::unordered_dense::map<Type, std::string> Type2String;
 
 		public:
 			explicit Packet(Type type) : type(type)

package/worker/include/RTC/RTCP/Sdes.hpp

@@ -84,7 +84,7 @@ namespace RTC
 			std::unique_ptr<uint8_t[]> raw;
 
 		private:
-			static const absl::flat_hash_map<SdesItem::Type, std::string> Type2String;
+			static const ankerl::unordered_dense::map<SdesItem::Type, std::string> Type2String;
 		};
 
 		class SdesChunk

package/worker/include/RTC/RTP/Codecs/DependencyDescriptor.hpp

@@ -3,6 +3,7 @@
 
 #include "common.hpp"
 #include "Utils.hpp" // BitStream.
+#include <ankerl/unordered_dense.h>
 
 namespace RTC
 {
@@ -31,7 +32,7 @@ namespace RTC
 				};
 
 			private:
-				static std::unordered_map<DecodeTargetIndication, std::string> dtiToString;
+				static ankerl::unordered_dense::map<DecodeTargetIndication, std::string> dtiToString;
 
 			private:
 				struct FrameDependencyTemplate