mediasoup 3.9.8 → 3.9.9

package/node/lib/Worker.js

@@ -81,7 +81,7 @@ class Worker extends EnhancedEventEmitter_1.EnhancedEventEmitter {
         // options
         {
             env: {
-                MEDIASOUP_VERSION: '3.9.8',
+                MEDIASOUP_VERSION: '3.9.9',
                 // Let the worker process inherit all environment variables, useful
                 // if a custom and not in the path GCC is used so the user can set
                 // LD_LIBRARY_PATH environment variable for runtime.

package/node/lib/index.d.ts

@@ -9,7 +9,7 @@ export { types };
 /**
  * Expose mediasoup version.
  */
-export declare const version = "3.9.8";
+export declare const version = "3.9.9";
 /**
  * Expose parseScalabilityMode() function.
  */

package/node/lib/index.js

@@ -11,7 +11,7 @@ exports.types = types;
 /**
  * Expose mediasoup version.
  */
-exports.version = '3.9.8';
+exports.version = '3.9.9';
 /**
  * Expose parseScalabilityMode() function.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mediasoup",
-  "version": "3.9.8",
+  "version": "3.9.9",
   "description": "Cutting Edge WebRTC Video Conferencing",
   "contributors": [
     "Iñaki Baz Castillo <ibc@aliax.net> (https://inakibaz.me)",

package/worker/include/Channel/ChannelRequest.hpp

@@ -2,9 +2,9 @@
 #define MS_CHANNEL_REQUEST_HPP
 
 #include "common.hpp"
+#include <absl/container/flat_hash_map.h>
 #include <nlohmann/json.hpp>
 #include <string>
-#include <unordered_map>
 
 using json = nlohmann::json;
 
@@ -75,7 +75,7 @@ namespace Channel
 		};
 
 	private:
-		static std::unordered_map<std::string, MethodId> string2MethodId;
+		static absl::flat_hash_map<std::string, MethodId> string2MethodId;
 
 	public:
 		ChannelRequest(Channel::ChannelSocket* channel, json& jsonRequest);

package/worker/include/DepUsrSCTP.hpp

@@ -4,7 +4,7 @@
 #include "common.hpp"
 #include "RTC/SctpAssociation.hpp"
 #include "handles/Timer.hpp"
-#include <unordered_map>
+#include <absl/container/flat_hash_map.h>
 
 class DepUsrSCTP
 {
@@ -42,7 +42,7 @@ private:
 	thread_local static Checker* checker;
 	static uint64_t numSctpAssociations;
 	static uintptr_t nextSctpAssociationId;
-	static std::unordered_map<uintptr_t, RTC::SctpAssociation*> mapIdSctpAssociation;
+	static absl::flat_hash_map<uintptr_t, RTC::SctpAssociation*> mapIdSctpAssociation;
 };
 
 #endif

package/worker/include/PayloadChannel/Notification.hpp

@@ -2,9 +2,9 @@
 #define MS_PAYLOAD_CHANNEL_NOTIFICATION_HPP
 
 #include "common.hpp"
+#include <absl/container/flat_hash_map.h>
 #include <nlohmann/json.hpp>
 #include <string>
-#include <unordered_map>
 
 using json = nlohmann::json;
 
@@ -24,7 +24,7 @@ namespace PayloadChannel
 		static bool IsNotification(json& jsonNotification);
 
 	private:
-		static std::unordered_map<std::string, EventId> string2EventId;
+		static absl::flat_hash_map<std::string, EventId> string2EventId;
 
 	public:
 		explicit Notification(json& jsonNotification);

package/worker/include/PayloadChannel/PayloadChannelRequest.hpp

@@ -2,9 +2,9 @@
 #define MS_PAYLOAD_CHANNEL_REQUEST_HPP
 
 #include "common.hpp"
+#include <absl/container/flat_hash_map.h>
 #include <nlohmann/json.hpp>
 #include <string>
-#include <unordered_map>
 
 using json = nlohmann::json;
 
@@ -26,7 +26,7 @@ namespace PayloadChannel
 		static bool IsRequest(json& jsonRequest);
 
 	private:
-		static std::unordered_map<std::string, MethodId> string2MethodId;
+		static absl::flat_hash_map<std::string, MethodId> string2MethodId;
 
 	public:
 		PayloadChannelRequest(PayloadChannel::PayloadChannelSocket* channel, json& jsonRequest);

package/worker/include/RTC/ActiveSpeakerObserver.hpp

@@ -3,8 +3,8 @@
 
 #include "RTC/RtpObserver.hpp"
 #include "handles/Timer.hpp"
+#include <absl/container/flat_hash_map.h>
 #include <nlohmann/json.hpp>
-#include <unordered_map>
 #include <utility>
 #include <vector>
 
@@ -89,7 +89,7 @@ namespace RTC
 		std::string dominantId{ "" };
 		Timer* periodicTimer{ nullptr };
 		uint16_t interval{ 300u };
-		std::unordered_map<std::string, struct ProducerSpeaker> mapProducerSpeaker;
+		absl::flat_hash_map<std::string, struct ProducerSpeaker> mapProducerSpeaker;
 		uint64_t lastLevelIdleTime{ 0 };
 	};
 } // namespace RTC

package/worker/include/RTC/AudioLevelObserver.hpp

@@ -3,8 +3,8 @@
 
 #include "RTC/RtpObserver.hpp"
 #include "handles/Timer.hpp"
+#include <absl/container/flat_hash_map.h>
 #include <nlohmann/json.hpp>
-#include <unordered_map>
 
 using json = nlohmann::json;
 
@@ -48,7 +48,7 @@ namespace RTC
 		// Allocated by this.
 		Timer* periodicTimer{ nullptr };
 		// Others.
-		std::unordered_map<RTC::Producer*, DBovs> mapProducerDBovs;
+		absl::flat_hash_map<RTC::Producer*, DBovs> mapProducerDBovs;
 		bool silence{ true };
 	};
 } // namespace RTC

package/worker/include/RTC/Consumer.hpp

@@ -14,9 +14,9 @@
 #include "RTC/RtpPacket.hpp"
 #include "RTC/RtpStream.hpp"
 #include "RTC/RtpStreamSend.hpp"
+#include <absl/container/flat_hash_set.h>
 #include <nlohmann/json.hpp>
 #include <string>
-#include <unordered_set>
 #include <vector>
 
 using json = nlohmann::json;
@@ -182,7 +182,7 @@ namespace RTC
 		struct RTC::RtpHeaderExtensionIds rtpHeaderExtensionIds;
 		const std::vector<uint8_t>* producerRtpStreamScores{ nullptr };
 		// Others.
-		std::unordered_set<uint8_t> supportedCodecPayloadTypes;
+		absl::flat_hash_set<uint8_t> supportedCodecPayloadTypes;
 		uint64_t lastRtcpSentTime{ 0u };
 		uint16_t maxRtcpInterval{ 0u };
 		bool externallyManagedBitrate{ false };

package/worker/include/RTC/DtlsTransport.hpp

@@ -7,7 +7,7 @@
 #include <openssl/bio.h>
 #include <openssl/ssl.h>
 #include <openssl/x509.h>
-#include <map>
+#include <absl/container/flat_hash_map.h>
 #include <string>
 #include <vector>
 
@@ -144,9 +144,9 @@ namespace RTC
 		thread_local static EVP_PKEY* privateKey;
 		thread_local static SSL_CTX* sslCtx;
 		thread_local static uint8_t sslReadBuffer[];
-		static std::map<std::string, Role> string2Role;
-		static std::map<std::string, FingerprintAlgorithm> string2FingerprintAlgorithm;
-		static std::map<FingerprintAlgorithm, std::string> fingerprintAlgorithm2String;
+		static absl::flat_hash_map<std::string, Role> string2Role;
+		static absl::flat_hash_map<std::string, FingerprintAlgorithm> string2FingerprintAlgorithm;
+		static absl::flat_hash_map<FingerprintAlgorithm, std::string> fingerprintAlgorithm2String;
 		thread_local static std::vector<Fingerprint> localFingerprints;
 		static std::vector<SrtpCryptoSuiteMapEntry> srtpCryptoSuites;
 

package/worker/include/RTC/KeyFrameRequestManager.hpp

@@ -2,7 +2,7 @@
 #define MS_KEY_FRAME_REQUEST_MANAGER_HPP
 
 #include "handles/Timer.hpp"
-#include <map>
+#include <absl/container/flat_hash_map.h>
 
 namespace RTC
 {
@@ -122,8 +122,8 @@ namespace RTC
 	private:
 		Listener* listener{ nullptr };
 		uint32_t keyFrameRequestDelay{ 0u }; // 0 means disabled.
-		std::map<uint32_t, PendingKeyFrameInfo*> mapSsrcPendingKeyFrameInfo;
-		std::map<uint32_t, KeyFrameRequestDelayer*> mapSsrcKeyFrameRequestDelayer;
+		absl::flat_hash_map<uint32_t, PendingKeyFrameInfo*> mapSsrcPendingKeyFrameInfo;
+		absl::flat_hash_map<uint32_t, KeyFrameRequestDelayer*> mapSsrcKeyFrameRequestDelayer;
 	};
 } // namespace RTC
 

package/worker/include/RTC/NackGenerator.hpp

@@ -5,6 +5,8 @@
 #include "RTC/RtpPacket.hpp"
 #include "RTC/SeqManager.hpp"
 #include "handles/Timer.hpp"
+#include <absl/container/btree_map.h>
+#include <absl/container/btree_set.h>
 #include <map>
 #include <set>
 #include <vector>
@@ -75,9 +77,9 @@ namespace RTC
 		// Allocated by this.
 		Timer* timer{ nullptr };
 		// Others.
-		std::map<uint16_t, NackInfo, RTC::SeqManager<uint16_t>::SeqLowerThan> nackList;
-		std::set<uint16_t, RTC::SeqManager<uint16_t>::SeqLowerThan> keyFrameList;
-		std::set<uint16_t, RTC::SeqManager<uint16_t>::SeqLowerThan> recoveredList;
+		absl::btree_map<uint16_t, NackInfo, RTC::SeqManager<uint16_t>::SeqLowerThan> nackList;
+		absl::btree_set<uint16_t, RTC::SeqManager<uint16_t>::SeqLowerThan> keyFrameList;
+		absl::btree_set<uint16_t, RTC::SeqManager<uint16_t>::SeqLowerThan> recoveredList;
 		bool started{ false };
 		uint16_t lastSeq{ 0u }; // Seq number of last valid packet.
 		uint32_t rtt{ 0u };     // Round trip time (ms).

package/worker/include/RTC/Parameters.hpp

@@ -2,9 +2,9 @@
 #define MS_RTC_PARAMETERS_HPP
 
 #include "common.hpp"
+#include <absl/container/flat_hash_map.h>
 #include <nlohmann/json.hpp>
 #include <string>
-#include <unordered_map>
 #include <vector>
 
 using json = nlohmann::json;
@@ -78,7 +78,7 @@ namespace RTC
 		const std::vector<int32_t>& GetArrayOfIntegers(const std::string& key) const;
 
 	private:
-		std::unordered_map<std::string, Value> mapKeyValues;
+		absl::flat_hash_map<std::string, Value> mapKeyValues;
 	};
 } // namespace RTC
 

package/worker/include/RTC/PipeConsumer.hpp

@@ -60,11 +60,11 @@ namespace RTC
 		// Allocated by this.
 		std::vector<RTC::RtpStreamSend*> rtpStreams;
 		// Others.
-		std::unordered_map<uint32_t, uint32_t> mapMappedSsrcSsrc;
-		std::unordered_map<uint32_t, RTC::RtpStreamSend*> mapSsrcRtpStream;
+		absl::flat_hash_map<uint32_t, uint32_t> mapMappedSsrcSsrc;
+		absl::flat_hash_map<uint32_t, RTC::RtpStreamSend*> mapSsrcRtpStream;
 		bool keyFrameSupported{ false };
-		std::unordered_map<RTC::RtpStreamSend*, bool> mapRtpStreamSyncRequired;
-		std::unordered_map<RTC::RtpStreamSend*, RTC::SeqManager<uint16_t>> mapRtpStreamRtpSeqManager;
+		absl::flat_hash_map<RTC::RtpStreamSend*, bool> mapRtpStreamSyncRequired;
+		absl::flat_hash_map<RTC::RtpStreamSend*, RTC::SeqManager<uint16_t>> mapRtpStreamRtpSeqManager;
 	};
 } // namespace RTC
 

package/worker/include/RTC/PlainTransport.hpp

@@ -5,7 +5,7 @@
 #include "RTC/Transport.hpp"
 #include "RTC/TransportTuple.hpp"
 #include "RTC/UdpSocket.hpp"
-#include <map>
+#include <absl/container/flat_hash_map.h>
 
 namespace RTC
 {
@@ -19,8 +19,8 @@ namespace RTC
 		};
 
 	private:
-		static std::map<std::string, RTC::SrtpSession::CryptoSuite> string2SrtpCryptoSuite;
-		static std::map<RTC::SrtpSession::CryptoSuite, std::string> srtpCryptoSuite2String;
+		static absl::flat_hash_map<std::string, RTC::SrtpSession::CryptoSuite> string2SrtpCryptoSuite;
+		static absl::flat_hash_map<RTC::SrtpSession::CryptoSuite, std::string> srtpCryptoSuite2String;
 		static size_t srtpMasterLength;
 
 	public:

package/worker/include/RTC/PortManager.hpp

@@ -4,9 +4,9 @@
 #include "common.hpp"
 #include "Settings.hpp"
 #include <uv.h>
+#include <absl/container/flat_hash_map.h>
 #include <nlohmann/json.hpp>
 #include <string>
-#include <unordered_map>
 #include <vector>
 
 namespace RTC
@@ -54,8 +54,8 @@ namespace RTC
 		static std::vector<bool>& GetPorts(Transport transport, const std::string& ip);
 
 	private:
-		thread_local static std::unordered_map<std::string, std::vector<bool>> mapUdpIpPorts;
-		thread_local static std::unordered_map<std::string, std::vector<bool>> mapTcpIpPorts;
+		thread_local static absl::flat_hash_map<std::string, std::vector<bool>> mapUdpIpPorts;
+		thread_local static absl::flat_hash_map<std::string, std::vector<bool>> mapTcpIpPorts;
 	};
 } // namespace RTC
 

package/worker/include/RTC/Producer.hpp

@@ -12,7 +12,6 @@
 #include "RTC/RtpHeaderExtensionIds.hpp"
 #include "RTC/RtpPacket.hpp"
 #include "RTC/RtpStreamRecv.hpp"
-#include <map>
 #include <nlohmann/json.hpp>
 #include <string>
 #include <vector>
@@ -55,7 +54,7 @@ namespace RTC
 	private:
 		struct RtpMapping
 		{
-			std::map<uint8_t, uint8_t> codecs;
+			absl::flat_hash_map<uint8_t, uint8_t> codecs;
 			std::vector<RtpEncodingMapping> encodings;
 		};
 
@@ -113,7 +112,7 @@ namespace RTC
 		{
 			return this->paused;
 		}
-		const std::map<RTC::RtpStreamRecv*, uint32_t>& GetRtpStreams()
+		const absl::flat_hash_map<RTC::RtpStreamRecv*, uint32_t>& GetRtpStreams()
 		{
 			return this->mapRtpStreamMappedSsrc;
 		}
@@ -161,7 +160,7 @@ namespace RTC
 		// Passed by argument.
 		RTC::Producer::Listener* listener{ nullptr };
 		// Allocated by this.
-		std::map<uint32_t, RTC::RtpStreamRecv*> mapSsrcRtpStream;
+		absl::flat_hash_map<uint32_t, RTC::RtpStreamRecv*> mapSsrcRtpStream;
 		RTC::KeyFrameRequestManager* keyFrameRequestManager{ nullptr };
 		// Others.
 		RTC::Media::Kind kind;
@@ -170,9 +169,9 @@ namespace RTC
 		struct RtpMapping rtpMapping;
 		std::vector<RTC::RtpStreamRecv*> rtpStreamByEncodingIdx;
 		std::vector<uint8_t> rtpStreamScores;
-		std::map<uint32_t, RTC::RtpStreamRecv*> mapRtxSsrcRtpStream;
-		std::map<RTC::RtpStreamRecv*, uint32_t> mapRtpStreamMappedSsrc;
-		std::map<uint32_t, uint32_t> mapMappedSsrcSsrc;
+		absl::flat_hash_map<uint32_t, RTC::RtpStreamRecv*> mapRtxSsrcRtpStream;
+		absl::flat_hash_map<RTC::RtpStreamRecv*, uint32_t> mapRtpStreamMappedSsrc;
+		absl::flat_hash_map<uint32_t, uint32_t> mapMappedSsrcSsrc;
 		struct RTC::RtpHeaderExtensionIds rtpHeaderExtensionIds;
 		bool paused{ false };
 		RTC::RtpPacket* currentRtpPacket{ nullptr };

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

@@ -4,6 +4,7 @@
 #include "common.hpp"
 #include "RTC/RTCP/FeedbackItem.hpp"
 #include "RTC/RTCP/Packet.hpp"
+#include <absl/container/flat_hash_map.h>
 
 namespace RTC
 {
@@ -27,7 +28,7 @@ namespace RTC
 			static const std::string& MessageType2String(typename T::MessageType type);
 
 		private:
-			static std::map<typename T::MessageType, std::string> type2String;
+			static absl::flat_hash_map<typename T::MessageType, std::string> type2String;
 
 		public:
 			typename T::MessageType GetMessageType() const

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

@@ -197,7 +197,7 @@ namespace RTC
 			static FeedbackRtpTransportPacket* Parse(const uint8_t* data, size_t len);
 
 		private:
-			static std::map<Status, std::string> status2String;
+			static absl::flat_hash_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 <map>
+#include <absl/container/flat_hash_map.h>
 #include <string>
 
 namespace RTC
@@ -72,7 +72,7 @@ namespace RTC
 			static const std::string& Type2String(Type type);
 
 		private:
-			static std::map<Type, std::string> type2String;
+			static absl::flat_hash_map<Type, std::string> type2String;
 
 		public:
 			explicit Packet(Type type) : type(type)

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

@@ -3,7 +3,6 @@
 
 #include "common.hpp"
 #include "RTC/RTCP/Packet.hpp"
-#include <map>
 #include <string>
 #include <vector>
 
@@ -77,7 +76,7 @@ namespace RTC
 			std::unique_ptr<uint8_t[]> raw;
 
 		private:
-			static std::map<SdesItem::Type, std::string> type2String;
+			static absl::flat_hash_map<SdesItem::Type, std::string> type2String;
 		};
 
 		class SdesChunk

package/worker/include/RTC/RateCalculator.hpp

@@ -24,8 +24,7 @@ namespace RTC
 		  : windowSizeMs(windowSizeMs), scale(scale), windowItems(windowItems)
 		{
 			this->itemSizeMs = std::max(windowSizeMs / windowItems, static_cast<size_t>(1));
-
-			Reset();
+			this->buffer.resize(windowItems);
 		}
 		void Update(size_t size, uint64_t nowMs);
 		uint32_t GetRate(uint64_t nowMs);
@@ -38,7 +37,9 @@ namespace RTC
 		void RemoveOldData(uint64_t nowMs);
 		void Reset()
 		{
-			this->buffer.reset(new BufferItem[this->windowItems]);
+			std::memset(
+			  static_cast<void*>(&this->buffer.front()), 0, sizeof(BufferItem) * this->buffer.size());
+
 			this->newestItemStartTime = 0u;
 			this->newestItemIndex     = -1;
 			this->oldestItemStartTime = 0u;
@@ -65,7 +66,7 @@ namespace RTC
 		// Item Size (in milliseconds), calculated as: windowSizeMs / windowItems.
 		size_t itemSizeMs{ 0u };
 		// Buffer to keep data.
-		std::unique_ptr<BufferItem[]> buffer;
+		std::vector<BufferItem> buffer;
 		// Time (in milliseconds) for last item in the time window.
 		uint64_t newestItemStartTime{ 0u };
 		// Index for the last item in the time window.

package/worker/include/RTC/Router.hpp

@@ -13,9 +13,9 @@
 #include "RTC/RtpPacket.hpp"
 #include "RTC/RtpStream.hpp"
 #include "RTC/Transport.hpp"
+#include <absl/container/flat_hash_map.h>
 #include <nlohmann/json.hpp>
 #include <string>
-#include <unordered_map>
 #include <unordered_set>
 
 using json = nlohmann::json;
@@ -93,16 +93,17 @@ namespace RTC
 
 	private:
 		// Allocated by this.
-		std::unordered_map<std::string, RTC::Transport*> mapTransports;
-		std::unordered_map<std::string, RTC::RtpObserver*> mapRtpObservers;
+		absl::flat_hash_map<std::string, RTC::Transport*> mapTransports;
+		absl::flat_hash_map<std::string, RTC::RtpObserver*> mapRtpObservers;
 		// Others.
-		std::unordered_map<RTC::Producer*, std::unordered_set<RTC::Consumer*>> mapProducerConsumers;
-		std::unordered_map<RTC::Consumer*, RTC::Producer*> mapConsumerProducer;
-		std::unordered_map<RTC::Producer*, std::unordered_set<RTC::RtpObserver*>> mapProducerRtpObservers;
-		std::unordered_map<std::string, RTC::Producer*> mapProducers;
-		std::unordered_map<RTC::DataProducer*, std::unordered_set<RTC::DataConsumer*>> mapDataProducerDataConsumers;
-		std::unordered_map<RTC::DataConsumer*, RTC::DataProducer*> mapDataConsumerDataProducer;
-		std::unordered_map<std::string, RTC::DataProducer*> mapDataProducers;
+		absl::flat_hash_map<RTC::Producer*, absl::flat_hash_set<RTC::Consumer*>> mapProducerConsumers;
+		absl::flat_hash_map<RTC::Consumer*, RTC::Producer*> mapConsumerProducer;
+		absl::flat_hash_map<RTC::Producer*, absl::flat_hash_set<RTC::RtpObserver*>> mapProducerRtpObservers;
+		absl::flat_hash_map<std::string, RTC::Producer*> mapProducers;
+		absl::flat_hash_map<RTC::DataProducer*, absl::flat_hash_set<RTC::DataConsumer*>>
+		  mapDataProducerDataConsumers;
+		absl::flat_hash_map<RTC::DataConsumer*, RTC::DataProducer*> mapDataConsumerDataProducer;
+		absl::flat_hash_map<std::string, RTC::DataProducer*> mapDataProducers;
 	};
 } // namespace RTC
 

package/worker/include/RTC/RtpDictionaries.hpp

@@ -3,10 +3,9 @@
 
 #include "common.hpp"
 #include "RTC/Parameters.hpp"
-#include <map>
+#include <absl/container/flat_hash_map.h>
 #include <nlohmann/json.hpp>
 #include <string>
-#include <unordered_map>
 #include <vector>
 
 using json = nlohmann::json;
@@ -29,8 +28,8 @@ namespace RTC
 		static const std::string& GetString(Kind kind);
 
 	private:
-		static std::unordered_map<std::string, Kind> string2Kind;
-		static std::map<Kind, std::string> kind2String;
+		static absl::flat_hash_map<std::string, Kind> string2Kind;
+		static absl::flat_hash_map<Kind, std::string> kind2String;
 	};
 
 	class RtpCodecMimeType
@@ -75,10 +74,10 @@ namespace RTC
 		};
 
 	public:
-		static std::unordered_map<std::string, Type> string2Type;
-		static std::map<Type, std::string> type2String;
-		static std::unordered_map<std::string, Subtype> string2Subtype;
-		static std::map<Subtype, std::string> subtype2String;
+		static absl::flat_hash_map<std::string, Type> string2Type;
+		static absl::flat_hash_map<Type, std::string> type2String;
+		static absl::flat_hash_map<std::string, Subtype> string2Subtype;
+		static absl::flat_hash_map<Subtype, std::string> subtype2String;
 
 	public:
 		RtpCodecMimeType() = default;
@@ -145,7 +144,7 @@ namespace RTC
 		};
 
 	private:
-		static std::unordered_map<std::string, Type> string2Type;
+		static absl::flat_hash_map<std::string, Type> string2Type;
 
 	public:
 		static Type GetType(std::string& uri);
@@ -269,8 +268,8 @@ namespace RTC
 		static std::string& GetTypeString(Type type);
 
 	private:
-		static std::unordered_map<std::string, Type> string2Type;
-		static std::map<Type, std::string> type2String;
+		static absl::flat_hash_map<std::string, Type> string2Type;
+		static absl::flat_hash_map<Type, std::string> type2String;
 
 	public:
 		RtpParameters() = default;

package/worker/include/RTC/RtpPacket.hpp

@@ -4,7 +4,8 @@
 #include "common.hpp"
 #include "Utils.hpp"
 #include "RTC/Codecs/PayloadDescriptorHandler.hpp"
-#include <map>
+#include <absl/container/flat_hash_map.h>
+#include <array>
 #include <nlohmann/json.hpp>
 #include <string>
 #include <vector>
@@ -473,9 +474,11 @@ namespace RTC
 			}
 			else if (HasOneByteExtensions())
 			{
-				auto it = this->mapOneByteExtensions.find(id);
+				if (id > 14)
+					return false;
 
-				return it != this->mapOneByteExtensions.end();
+				// `-1` because we have 14 elements total 0..13 and `id` is in the range 1..14.
+				return this->oneByteExtensions[id - 1] != nullptr;
 			}
 			else if (HasTwoBytesExtensions())
 			{
@@ -508,12 +511,14 @@ namespace RTC
 			}
 			else if (HasOneByteExtensions())
 			{
-				auto it = this->mapOneByteExtensions.find(id);
-
-				if (it == this->mapOneByteExtensions.end())
+				if (id > 14)
 					return nullptr;
 
-				auto* extension = it->second;
+				// `-1` because we have 14 elements total 0..13 and `id` is in the range 1..14.
+				auto* extension = this->oneByteExtensions[id - 1];
+
+				if (!extension)
+					return nullptr;
 
 				// In One-Byte extensions value length 0 means 1.
 				len = extension->len + 1;
@@ -611,8 +616,10 @@ namespace RTC
 		Header* header{ nullptr };
 		uint8_t* csrcList{ nullptr };
 		HeaderExtension* headerExtension{ nullptr };
-		std::map<uint8_t, OneByteExtension*> mapOneByteExtensions;
-		std::map<uint8_t, TwoBytesExtension*> mapTwoBytesExtensions;
+		// There might be up to 14 one-byte header extensions
+		// (https://datatracker.ietf.org/doc/html/rfc5285#section-4.2), use std::array.
+		std::array<OneByteExtension*, 14> oneByteExtensions;
+		absl::flat_hash_map<uint8_t, TwoBytesExtension*> mapTwoBytesExtensions;
 		uint8_t midExtensionId{ 0u };
 		uint8_t ridExtensionId{ 0u };
 		uint8_t rridExtensionId{ 0u };

package/worker/include/RTC/SenderBandwidthEstimator.hpp

@@ -6,6 +6,7 @@
 #include "RTC/RateCalculator.hpp"
 #include "RTC/SeqManager.hpp"
 #include "RTC/TrendCalculator.hpp"
+#include <absl/container/btree_map.h>
 #include <map>
 
 namespace RTC
@@ -102,7 +103,7 @@ namespace RTC
 		uint32_t initialAvailableBitrate{ 0u };
 		uint32_t availableBitrate{ 0u };
 		uint64_t lastAvailableBitrateEventAtMs{ 0u };
-		std::map<uint16_t, SentInfo, RTC::SeqManager<uint16_t>::SeqLowerThan> sentInfos;
+		absl::btree_map<uint16_t, SentInfo, RTC::SeqManager<uint16_t>::SeqLowerThan> sentInfos;
 		float rtt{ 0 }; // Round trip time in ms.
 		CummulativeResult cummulativeResult;
 		CummulativeResult probationCummulativeResult;

package/worker/include/RTC/SimulcastConsumer.hpp

@@ -97,7 +97,7 @@ namespace RTC
 		// Allocated by this.
 		RTC::RtpStreamSend* rtpStream{ nullptr };
 		// Others.
-		std::unordered_map<uint32_t, int16_t> mapMappedSsrcSpatialLayer;
+		absl::flat_hash_map<uint32_t, int16_t> mapMappedSsrcSpatialLayer;
 		std::vector<RTC::RtpStreamSend*> rtpStreams;
 		std::vector<RTC::RtpStream*> producerRtpStreams; // Indexed by spatial layer.
 		bool syncRequired{ false };