mediasoup 3.20.0 → 3.20.2

package/node/lib/test/test-Consumer.js

@@ -241,6 +241,111 @@ const ctx = {
             },
         ],
     }),
+    vpxMediaCodecs: utils.deepFreeze([
+        {
+            kind: 'video',
+            mimeType: 'video/VP8',
+            clockRate: 90000,
+            rtcpFeedback: [
+                { type: 'nack', parameter: '' },
+                { type: 'nack', parameter: 'pli' },
+                { type: 'ccm', parameter: 'fir' },
+                { type: 'goog-remb', parameter: '' },
+            ],
+        },
+        {
+            kind: 'video',
+            mimeType: 'video/VP9',
+            clockRate: 90000,
+            rtcpFeedback: [
+                { type: 'nack', parameter: '' },
+                { type: 'nack', parameter: 'pli' },
+                { type: 'ccm', parameter: 'fir' },
+                { type: 'goog-remb', parameter: '' },
+            ],
+        },
+    ]),
+    vp9SvcProducerOptions: utils.deepFreeze({
+        kind: 'video',
+        rtpParameters: {
+            mid: 'VIDEOSVC',
+            codecs: [
+                {
+                    mimeType: 'video/VP9',
+                    payloadType: 96,
+                    clockRate: 90000,
+                    parameters: {},
+                    rtcpFeedback: [
+                        { type: 'nack', parameter: '' },
+                        { type: 'nack', parameter: 'pli' },
+                        { type: 'ccm', parameter: 'fir' },
+                        { type: 'goog-remb', parameter: '' },
+                    ],
+                },
+            ],
+            headerExtensions: [],
+            encodings: [{ ssrc: 33333333, scalabilityMode: 'L3T3' }],
+            rtcp: { cname: 'FOOBAR' },
+        },
+        appData: { foo: 1, bar: '2' },
+    }),
+    vp8SimulcastProducerOptions: utils.deepFreeze({
+        kind: 'video',
+        rtpParameters: {
+            mid: 'VIDEOVP8',
+            codecs: [
+                {
+                    mimeType: 'video/VP8',
+                    payloadType: 96,
+                    clockRate: 90000,
+                    parameters: {},
+                    rtcpFeedback: [
+                        { type: 'nack', parameter: '' },
+                        { type: 'nack', parameter: 'pli' },
+                        { type: 'ccm', parameter: 'fir' },
+                        { type: 'goog-remb', parameter: '' },
+                    ],
+                },
+            ],
+            headerExtensions: [],
+            encodings: [
+                { ssrc: 44444441, scalabilityMode: 'L1T5' },
+                { ssrc: 44444442, scalabilityMode: 'L1T5' },
+                { ssrc: 44444443, scalabilityMode: 'L1T5' },
+            ],
+            rtcp: { cname: 'FOOBAR' },
+        },
+        appData: { foo: 1, bar: '2' },
+    }),
+    vpxConsumerDeviceCapabilities: utils.deepFreeze({
+        codecs: [
+            {
+                kind: 'video',
+                mimeType: 'video/VP8',
+                preferredPayloadType: 101,
+                clockRate: 90000,
+                rtcpFeedback: [
+                    { type: 'nack', parameter: '' },
+                    { type: 'nack', parameter: 'pli' },
+                    { type: 'ccm', parameter: 'fir' },
+                    { type: 'goog-remb', parameter: '' },
+                ],
+            },
+            {
+                kind: 'video',
+                mimeType: 'video/VP9',
+                preferredPayloadType: 102,
+                clockRate: 90000,
+                rtcpFeedback: [
+                    { type: 'nack', parameter: '' },
+                    { type: 'nack', parameter: 'pli' },
+                    { type: 'ccm', parameter: 'fir' },
+                    { type: 'goog-remb', parameter: '' },
+                ],
+            },
+        ],
+        headerExtensions: [],
+    }),
 };
 beforeEach(async () => {
     ctx.worker = await mediasoup.createWorker();
@@ -822,6 +927,95 @@ test('consumer.setPreferredLayers() with wrong arguments rejects with TypeError'
     // @ts-expect-error --- Testing purposes.
     videoConsumer.setPreferredLayers({ temporalLayer: 2 })).rejects.toThrow(TypeError);
 }, 2000);
+test('transport.consume() for an SVC producer honors preferredLayers', async () => {
+    const router = await ctx.worker.createRouter({
+        mediaCodecs: ctx.vpxMediaCodecs,
+    });
+    const transport1 = await router.createWebRtcTransport({
+        listenIps: ['127.0.0.1'],
+    });
+    const transport2 = await router.createWebRtcTransport({
+        listenIps: ['127.0.0.1'],
+    });
+    const deviceCapabilities = ctx.vpxConsumerDeviceCapabilities;
+    const svcProducer = await transport1.produce(ctx.vp9SvcProducerOptions);
+    expect(router.canConsume({
+        producerId: svcProducer.id,
+        rtpCapabilities: deviceCapabilities,
+    })).toBe(true);
+    const svcConsumer = await transport2.consume({
+        producerId: svcProducer.id,
+        rtpCapabilities: deviceCapabilities,
+        paused: true,
+        preferredLayers: { spatialLayer: 1, temporalLayer: 0 },
+    });
+    expect(svcConsumer.type).toBe('svc');
+    expect(svcConsumer.preferredLayers).toEqual({
+        spatialLayer: 1,
+        temporalLayer: 0,
+    });
+    // Out-of-range spatial and temporal layers are clamped to the max.
+    const svcConsumerClamped = await transport2.consume({
+        producerId: svcProducer.id,
+        rtpCapabilities: deviceCapabilities,
+        paused: true,
+        preferredLayers: { spatialLayer: 9, temporalLayer: 9 },
+    });
+    expect(svcConsumerClamped.preferredLayers).toEqual({
+        spatialLayer: 2,
+        temporalLayer: 2,
+    });
+    // When no temporal layer is given it defaults to the max temporal layer.
+    const svcConsumerNoTemporal = await transport2.consume({
+        producerId: svcProducer.id,
+        rtpCapabilities: deviceCapabilities,
+        paused: true,
+        preferredLayers: { spatialLayer: 1 },
+    });
+    expect(svcConsumerNoTemporal.preferredLayers).toEqual({
+        spatialLayer: 1,
+        temporalLayer: 2,
+    });
+}, 2000);
+test('transport.consume() for a simulcast producer honors preferredLayers', async () => {
+    const router = await ctx.worker.createRouter({
+        mediaCodecs: ctx.vpxMediaCodecs,
+    });
+    const transport1 = await router.createWebRtcTransport({
+        listenIps: ['127.0.0.1'],
+    });
+    const transport2 = await router.createWebRtcTransport({
+        listenIps: ['127.0.0.1'],
+    });
+    const deviceCapabilities = ctx.vpxConsumerDeviceCapabilities;
+    const simulcastProducer = await transport1.produce(ctx.vp8SimulcastProducerOptions);
+    expect(router.canConsume({
+        producerId: simulcastProducer.id,
+        rtpCapabilities: deviceCapabilities,
+    })).toBe(true);
+    const simulcastConsumer = await transport2.consume({
+        producerId: simulcastProducer.id,
+        rtpCapabilities: deviceCapabilities,
+        paused: true,
+        preferredLayers: { spatialLayer: 1, temporalLayer: 0 },
+    });
+    expect(simulcastConsumer.type).toBe('simulcast');
+    expect(simulcastConsumer.preferredLayers).toEqual({
+        spatialLayer: 1,
+        temporalLayer: 0,
+    });
+    // Out-of-range spatial layer is clamped to the max (2 = number of encodings - 1).
+    const simulcastConsumerClamped = await transport2.consume({
+        producerId: simulcastProducer.id,
+        rtpCapabilities: deviceCapabilities,
+        paused: true,
+        preferredLayers: { spatialLayer: 9, temporalLayer: 9 },
+    });
+    expect(simulcastConsumerClamped.preferredLayers).toEqual({
+        spatialLayer: 2,
+        temporalLayer: 4,
+    });
+}, 2000);
 test('consumer.setPriority() succeed', async () => {
     const videoConsumer = await ctx.webRtcTransport2.consume({
         producerId: ctx.videoProducer.id,

package/node/lib/test/test-DataConsumer.js

@@ -283,6 +283,12 @@ test('dataConsumer.getStats() on a DirectTransport succeeds', async () => {
         },
     ]);
 }, 2000);
+test('dataConsumer.send() on a DirectTransport rejects with TypeError', async () => {
+    const dataConsumer = await ctx.directTransport.consumeData({
+        dataProducerId: ctx.sctpDataProducer.id,
+    });
+    await expect(dataConsumer.send('foo')).rejects.toThrow(TypeError);
+}, 2000);
 test('dataConsumer.pause() and resume() succeed', async () => {
     const onObserverPause = jest.fn();
     const onObserverResume = jest.fn();

package/node/lib/test/test-Router.js

@@ -147,6 +147,17 @@ test('worker.createRouter() rejects with InvalidStateError if Worker is closed',
     ctx.worker.close();
     await expect(ctx.worker.createRouter({ mediaCodecs: ctx.mediaCodecs })).rejects.toThrow(errors_1.InvalidStateError);
 }, 2000);
+test('router.rtpCapabilities getter returns cloned RTP capabilities', async () => {
+    const router = await ctx.worker.createRouter({
+        mediaCodecs: ctx.mediaCodecs,
+    });
+    const originalRouterRtpCapabilities = router.rtpCapabilities;
+    const clonedOriginalRouterRtpCapabilities = utils.deepFreeze(originalRouterRtpCapabilities);
+    // Application attempts to modify router RTP capabilities, but it's modifying
+    // a returned clone of them.
+    router.rtpCapabilities.headerExtensions = [];
+    expect(router.rtpCapabilities).toEqual(clonedOriginalRouterRtpCapabilities);
+}, 2000);
 test('router.updateMediaCodecs() succeeds', async () => {
     const router = await ctx.worker.createRouter({
         mediaCodecs: ctx.mediaCodecs,

package/node/lib/test/test-werift-sctp.js

@@ -190,4 +190,11 @@ test('ordered DataProducer delivers all SCTP messages to the DataConsumer', asyn
             bytesSent: recvMessageBytes,
         },
     ]);
+    expect(await ctx.dataConsumer.getBufferedAmount()).toBe(0);
 }, 10000);
+test('can send messages from the SCTP DataConsumer', async () => {
+    expect(await ctx.dataConsumer.getBufferedAmount()).toBe(0);
+    // We can send messages directly from the DataConsumer and it should return
+    // current buffered amount, so 0 bytes.
+    await expect(ctx.dataConsumer.send('foo')).resolves.toBe(0);
+}, 2000);

package/npm-scripts.mjs

@@ -539,8 +539,8 @@ async function release() {
 		exitWithError();
 	}
 
-	// await checkRelease();
-	// executeCmd(`git commit -am '${pkg.version}'`);
+	await checkRelease();
+	executeCmd(`git commit -am '${pkg.version}'`);
 	executeCmd(`git tag -a ${pkg.version} -m '${pkg.version}'`);
 	executeCmd(`git push origin v${MAYOR_VERSION}`);
 	executeCmd(`git push origin '${pkg.version}'`);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mediasoup",
-	"version": "3.20.0",
+	"version": "3.20.2",
 	"description": "Cutting Edge WebRTC Video Conferencing",
 	"contributors": [
 		"Iñaki Baz Castillo <ibc@aliax.net> (https://inakibaz.me)",
@@ -56,6 +56,7 @@
 		"worker/scripts/*.py",
 		"worker/scripts/*.sh",
 		"worker/subprojects/*.wrap",
+		"worker/subprojects/packagefiles",
 		"worker/test/include",
 		"worker/test/src",
 		"worker/meson.build",
@@ -104,7 +105,7 @@
 		"h264-profile-level-id": "^2.3.2",
 		"node-fetch": "^3.3.2",
 		"supports-color": "^10.2.2",
-		"tar": "^7.5.15"
+		"tar": "^7.5.16"
 	},
 	"devDependencies": {
 		"@eslint/js": "^10.0.1",
@@ -113,21 +114,21 @@
 		"@types/ini": "^4.1.1",
 		"@types/jest": "^30.0.0",
 		"@types/node": "^25.6.2",
-		"eslint": "^10.4.0",
+		"eslint": "^10.4.1",
 		"eslint-config-prettier": "^10.1.8",
 		"eslint-plugin-jest": "^29.15.2",
-		"eslint-plugin-prettier": "^5.5.5",
+		"eslint-plugin-prettier": "^5.5.6",
 		"globals": "^17.6.0",
 		"ini": "^6.0.0",
 		"jest": "^30.4.2",
-		"knip": "^6.14.2",
+		"knip": "^6.15.0",
 		"marked": "^18.0.4",
 		"open-cli": "^9.0.0",
 		"pick-port": "^2.2.0",
 		"prettier": "^3.8.3",
 		"ts-jest": "^29.4.11",
 		"typescript": "^6.0.3",
-		"typescript-eslint": "^8.60.0",
+		"typescript-eslint": "^8.60.1",
 		"werift-sctp": "^0.0.11"
 	}
 }

package/worker/Makefile

@@ -24,6 +24,7 @@ endif
 	clean-pip \
 	clean-subprojects \
 	clean-all \
+	check-wrap-status \
 	update-wrap-file \
 	mediasoup-worker \
 	libmediasoup-worker \
@@ -75,9 +76,12 @@ clean-subprojects: invoke
 clean-all: invoke
 	"$(PYTHON)" -m invoke clean-all
 
+check-wrap-status: invoke
+	"$(PYTHON)" -m invoke check-wrap-status
+
 # It requires the SUBPROJECT environment variable.
 update-wrap-file: invoke
-	"$(PYTHON)" -m invoke subprojects $(SUBPROJECT)
+	"$(PYTHON)" -m invoke update-wrap-file $(SUBPROJECT)
 
 mediasoup-worker: invoke
 	"$(PYTHON)" -m invoke mediasoup-worker

package/worker/deps/libwebrtc/meson.build

@@ -49,8 +49,10 @@ abseil_cpp_proj = subproject(
   'abseil-cpp',
   default_options: [
     'warning_level=0',
+    'cpp_std=c++17',
   ],
 )
+
 local_include_directories = declare_dependency(
   include_directories: include_directories('libwebrtc')
 )
@@ -60,11 +62,12 @@ libwebrtc = library(
   libwebrtc_sources,
   dependencies: [
     local_include_directories,
+    libuv_proj.get_variable('libuv_dep'),
     openssl_proj.get_variable('openssl_dep'),
     abseil_cpp_proj.get_variable('absl_strings_dep'),
     abseil_cpp_proj.get_variable('absl_types_dep'),
+    ankerl_unordered_dense_dep,
     flatbuffers_proj.get_variable('flatbuffers_dep'),
-    libuv_proj.get_variable('libuv_dep'),
   ],
   include_directories: libwebrtc_include_directories,
   cpp_args: cpp_args,
@@ -75,6 +78,7 @@ libwebrtc_dep = declare_dependency(
     local_include_directories,
     abseil_cpp_proj.get_variable('absl_strings_dep'),
     abseil_cpp_proj.get_variable('absl_types_dep'),
+    ankerl_unordered_dense_dep,
   ],
   include_directories: include_directories('.'),
   link_with: libwebrtc,

package/worker/fbs/dataConsumer.fbs

@@ -44,6 +44,10 @@ table SendRequest {
     data: [uint8] (required);
 }
 
+table SendResponse {
+    buffered_amount: uint32 = 0;
+}
+
 table SetSubchannelsRequest {
     subchannels: [uint16] (required);
 }

package/worker/fbs/response.fbs

@@ -39,6 +39,7 @@ union Body {
     DataConsumer_GetBufferedAmountResponse: FBS.DataConsumer.GetBufferedAmountResponse,
     DataConsumer_DumpResponse: FBS.DataConsumer.DumpResponse,
     DataConsumer_GetStatsResponse: FBS.DataConsumer.GetStatsResponse,
+    DataConsumer_SendResponse: FBS.DataConsumer.SendResponse,
     DataConsumer_SetSubchannelsResponse: FBS.DataConsumer.SetSubchannelsResponse,
     DataConsumer_AddSubchannelResponse: FBS.DataConsumer.AddSubchannelResponse,
     DataConsumer_RemoveSubchannelResponse: FBS.DataConsumer.RemoveSubchannelResponse

package/worker/fuzzer/src/RTC/RTP/FuzzerPacket.cpp

@@ -19,7 +19,7 @@ void FuzzerRtcRtcPacket::Fuzz(const uint8_t* data, size_t len)
 		return;
 	}
 
-	// We need to serialize the Packet into a separate buffer because setters
+	// We need to serialize the packet into a separate buffer because setters
 	// below will try to write into packet memory.
 	//
 	// NOTE: Let's make the buffer bigger to test API that increases packet size.
@@ -180,7 +180,7 @@ void FuzzerRtcRtcPacket::Fuzz(const uint8_t* data, size_t len)
 	  value3                                                   // value
 	);
 
-	// NOTE: Cannot use One-Byte Extensions because we are using big ids and
+	// NOTE: Cannot use One-Byte extensions because we are using big ids and
 	// lengths.
 	// packet->SetExtensions(RTC::RTP::Packet::ExtensionsType::OneByte, extensions);
 	packet->SetExtensions(RTC::RTP::Packet::ExtensionsType::TwoBytes, extensions);

package/worker/include/Channel/ChannelMessageRegistrator.hpp

@@ -3,8 +3,8 @@
 
 #include "Channel/ChannelMessageRegistratorInterface.hpp"
 #include "Channel/ChannelSocket.hpp"
+#include <ankerl/unordered_dense.h>
 #include <string>
-#include <unordered_map>
 
 namespace Channel
 {
@@ -31,8 +31,9 @@ namespace Channel
 		ChannelSocket::NotificationHandler* GetChannelNotificationHandler(const std::string& id) override;
 
 	private:
-		std::unordered_map<std::string, ChannelSocket::RequestHandler*> mapChannelRequestHandlers;
-		std::unordered_map<std::string, ChannelSocket::NotificationHandler*> mapChannelNotificationHandlers;
+		ankerl::unordered_dense::map<std::string, ChannelSocket::RequestHandler*> mapChannelRequestHandlers;
+		ankerl::unordered_dense::map<std::string, ChannelSocket::NotificationHandler*>
+		  mapChannelNotificationHandlers;
 	};
 } // namespace Channel
 

package/worker/include/Channel/ChannelNotification.hpp

@@ -2,7 +2,6 @@
 #define MS_CHANNEL_NOTIFICATION_HPP
 
 #include "FBS/notification.h"
-#include <absl/container/flat_hash_map.h>
 #include <string>
 
 namespace Channel
@@ -12,9 +11,6 @@ namespace Channel
 	public:
 		using Event = FBS::Notification::Event;
 
-	private:
-		static const absl::flat_hash_map<FBS::Notification::Event, const char*> Event2String;
-
 	public:
 		explicit ChannelNotification(const FBS::Notification::Notification* notification);
 		~ChannelNotification() = default;

package/worker/include/Channel/ChannelRequest.hpp

@@ -5,8 +5,6 @@
 #include "FBS/message.h"
 #include "FBS/request.h"
 #include "FBS/response.h"
-#include <flatbuffers/minireflect.h>
-#include <absl/container/flat_hash_map.h>
 #include <string>
 
 namespace Channel
@@ -22,7 +20,6 @@ namespace Channel
 
 	public:
 		static thread_local flatbuffers::FlatBufferBuilder bufferBuilder;
-		static const absl::flat_hash_map<FBS::Request::Method, const char*> Method2String;
 
 	public:
 		ChannelRequest(Channel::ChannelSocket* channel, const FBS::Request::Request* request);
@@ -49,7 +46,9 @@ namespace Channel
 			  FBS::Message::CreateMessage(builder, FBS::Message::Body::Response, response.Union());
 
 			builder.FinishSizePrefixed(message);
-			this->Send(builder.GetBufferPointer(), builder.GetSize());
+
+			Send(builder.GetBufferPointer(), builder.GetSize());
+
 			builder.Clear();
 		}
 

package/worker/include/DepLibSRTP.hpp

@@ -2,8 +2,8 @@
 #define MS_DEP_LIBSRTP_HPP
 
 #include <srtp.h>
+#include <ankerl/unordered_dense.h>
 #include <string>
-#include <unordered_map>
 
 class DepLibSRTP
 {
@@ -20,7 +20,7 @@ public:
 	static const std::string& GetErrorString(srtp_err_status_t code);
 
 private:
-	static const std::unordered_map<srtp_err_status_t, std::string> ErrorCode2String;
+	static const ankerl::unordered_dense::map<srtp_err_status_t, std::string> ErrorCode2String;
 };
 
 #endif

package/worker/include/RTC/ActiveSpeakerObserver.hpp

@@ -4,7 +4,7 @@
 #include "handles/TimerHandleInterface.hpp"
 #include "RTC/RtpObserver.hpp"
 #include "SharedInterface.hpp"
-#include <absl/container/flat_hash_map.h>
+#include <ankerl/unordered_dense.h>
 #include <vector>
 
 // Implementation of Dominant Speaker Identification for Multipoint
@@ -101,7 +101,7 @@ namespace RTC
 		TimerHandleInterface* periodicTimer{ nullptr };
 		uint16_t interval{ 300u };
 		// Map of ProducerSpeakers indexed by Producer id.
-		absl::flat_hash_map<std::string, ProducerSpeaker*> mapProducerSpeakers;
+		ankerl::unordered_dense::map<std::string, ProducerSpeaker*> mapProducerSpeakers;
 		uint64_t lastLevelIdleTime{ 0u };
 	};
 } // namespace RTC

package/worker/include/RTC/AudioLevelObserver.hpp

@@ -4,7 +4,7 @@
 #include "handles/TimerHandleInterface.hpp"
 #include "RTC/RtpObserver.hpp"
 #include "SharedInterface.hpp"
-#include <absl/container/flat_hash_map.h>
+#include <ankerl/unordered_dense.h>
 
 namespace RTC
 {
@@ -50,7 +50,7 @@ namespace RTC
 		// Allocated by this.
 		TimerHandleInterface* periodicTimer{ nullptr };
 		// Others.
-		absl::flat_hash_map<RTC::Producer*, DBovs> mapProducerDBovs;
+		ankerl::unordered_dense::map<RTC::Producer*, DBovs> mapProducerDBovs;
 		bool silence{ true };
 	};
 } // namespace RTC

package/worker/include/RTC/Consumer.hpp

@@ -17,7 +17,7 @@
 #include "RTC/RTP/SharedPacket.hpp"
 #include "RTC/RtpDictionaries.hpp"
 #include "SharedInterface.hpp"
-#include <absl/container/flat_hash_set.h>
+#include <bitset>
 #include <string>
 #include <vector>
 

package/worker/include/RTC/DataConsumer.hpp

@@ -7,7 +7,7 @@
 #include "RTC/SCTP/public/Message.hpp"
 #include "RTC/SctpDictionaries.hpp"
 #include "SharedInterface.hpp"
-#include <absl/container/flat_hash_set.h>
+#include <ankerl/unordered_dense.h>
 #include <string>
 
 namespace RTC
@@ -121,7 +121,7 @@ namespace RTC
 		RTC::SctpStreamParameters sctpStreamParameters;
 		std::string label;
 		std::string protocol;
-		absl::flat_hash_set<uint16_t> subchannels;
+		ankerl::unordered_dense::set<uint16_t> subchannels;
 		bool transportConnected{ false };
 		bool sctpAssociationConnected{ false };
 		bool paused{ false };

package/worker/include/RTC/DtlsTransport.hpp

@@ -9,7 +9,7 @@
 #include <openssl/bio.h>
 #include <openssl/ssl.h>
 #include <openssl/x509.h>
-#include <absl/container/flat_hash_map.h>
+#include <ankerl/unordered_dense.h>
 #include <string>
 #include <vector>
 
@@ -129,9 +129,9 @@ namespace RTC
 		static thread_local EVP_PKEY* privateKey;
 		static thread_local SSL_CTX* sslCtx;
 		static thread_local uint8_t sslReadBuffer[];
-		static const absl::flat_hash_map<std::string, Role> String2Role;
-		static const absl::flat_hash_map<std::string, FingerprintAlgorithm> String2FingerprintAlgorithm;
-		static const absl::flat_hash_map<FingerprintAlgorithm, std::string> FingerprintAlgorithm2String;
+		static const ankerl::unordered_dense::map<std::string, Role> String2Role;
+		static const ankerl::unordered_dense::map<std::string, FingerprintAlgorithm> String2FingerprintAlgorithm;
+		static const ankerl::unordered_dense::map<FingerprintAlgorithm, std::string> FingerprintAlgorithm2String;
 		static thread_local std::vector<Fingerprint> localFingerprints;
 		static const std::vector<SrtpCryptoSuiteMapEntry> SrtpCryptoSuites;
 

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

@@ -7,9 +7,9 @@
 #include "RTC/ICE/StunPacket.hpp"
 #include "RTC/TransportTuple.hpp"
 #include "SharedInterface.hpp"
+#include <ankerl/unordered_dense.h>
 #include <list>
 #include <string>
-#include <unordered_map>
 
 namespace RTC
 {
@@ -61,7 +61,7 @@ namespace RTC
 			static FBS::WebRtcTransport::IceState IceStateToFbs(IceState state);
 
 		private:
-			static std::unordered_map<IceState, std::string> iceStateToString;
+			static ankerl::unordered_dense::map<IceState, std::string> iceStateToString;
 
 		public:
 			IceServer(