mediasoup 3.23.2 → 3.24.0

package/worker/src/handles/TcpConnectionHandle.cpp

@@ -12,6 +12,8 @@
 
 inline static void onAlloc(uv_handle_t* handle, size_t suggestedSize, uv_buf_t* buf)
 {
+	MS_TRACE();
+
 	auto* connection = static_cast<TcpConnectionHandle*>(handle->data);
 
 	if (connection)
@@ -22,6 +24,8 @@ inline static void onAlloc(uv_handle_t* handle, size_t suggestedSize, uv_buf_t*
 
 inline static void onRead(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf)
 {
+	MS_TRACE();
+
 	auto* connection = static_cast<TcpConnectionHandle*>(handle->data);
 
 	if (connection)
@@ -32,6 +36,8 @@ inline static void onRead(uv_stream_t* handle, ssize_t nread, const uv_buf_t* bu
 
 inline static void onWrite(uv_write_t* req, int status)
 {
+	MS_TRACE();
+
 	auto* writeData  = static_cast<TcpConnectionHandle::UvWriteData*>(req->data);
 	auto* handle     = req->handle;
 	auto* connection = static_cast<TcpConnectionHandle*>(handle->data);
@@ -50,11 +56,15 @@ inline static void onWrite(uv_write_t* req, int status)
 // ensuring that we call `delete xxx` with same type as `new xxx` before.
 inline static void onCloseTcp(uv_handle_t* handle)
 {
+	MS_TRACE();
+
 	delete reinterpret_cast<uv_tcp_t*>(handle);
 }
 
 inline static void onShutdown(uv_shutdown_t* req, int /*status*/)
 {
+	MS_TRACE();
+
 	auto* handle = req->handle;
 
 	delete req;
@@ -104,6 +114,8 @@ void TcpConnectionHandle::TriggerClose()
 
 void TcpConnectionHandle::Dump(int indentation) const
 {
+	MS_TRACE();
+
 	MS_DUMP_CLEAN(indentation, "<TcpConnectionHandle>");
 	MS_DUMP_CLEAN(indentation, "  local IP: %s", this->localIp.c_str());
 	MS_DUMP_CLEAN(indentation, "  local port: %" PRIu16, static_cast<uint16_t>(this->localPort));

package/worker/src/handles/TcpServerHandle.cpp

@@ -14,6 +14,8 @@ static constexpr int ListenBacklog{ 512 };
 
 inline static void onConnection(uv_stream_t* handle, int status)
 {
+	MS_TRACE();
+
 	auto* server = static_cast<TcpServerHandle*>(handle->data);
 
 	if (server)
@@ -24,6 +26,8 @@ inline static void onConnection(uv_stream_t* handle, int status)
 
 inline static void onCloseTcp(uv_handle_t* handle)
 {
+	MS_TRACE();
+
 	delete reinterpret_cast<uv_tcp_t*>(handle);
 }
 
@@ -71,6 +75,8 @@ TcpServerHandle::~TcpServerHandle()
 
 void TcpServerHandle::Dump(int indentation) const
 {
+	MS_TRACE();
+
 	MS_DUMP_CLEAN(indentation, "<TcpServerHandle>");
 	MS_DUMP_CLEAN(indentation, "  local IP: %s", this->localIp.c_str());
 	MS_DUMP_CLEAN(indentation, "  local port: %" PRIu16, static_cast<uint16_t>(this->localPort));

package/worker/src/handles/TimerHandle.cpp

@@ -10,11 +10,15 @@
 
 static void onTimer(uv_timer_t* handle)
 {
+	MS_TRACE();
+
 	static_cast<TimerHandle*>(handle->data)->OnUvTimer();
 }
 
 static void onCloseTimer(uv_handle_t* handle)
 {
+	MS_TRACE();
+
 	delete reinterpret_cast<uv_timer_t*>(handle);
 }
 

package/worker/src/handles/UdpSocketHandle.cpp

@@ -20,6 +20,8 @@ alignas(4) static thread_local uint8_t ReadBuffer[ReadBufferSize];
 
 inline static void onAlloc(uv_handle_t* handle, size_t suggestedSize, uv_buf_t* buf)
 {
+	MS_TRACE();
+
 	auto* socket = static_cast<UdpSocketHandle*>(handle->data);
 
 	if (socket)
@@ -31,6 +33,8 @@ inline static void onAlloc(uv_handle_t* handle, size_t suggestedSize, uv_buf_t*
 inline static void onRecv(
   uv_udp_t* handle, ssize_t nread, const uv_buf_t* buf, const struct sockaddr* addr, unsigned int flags)
 {
+	MS_TRACE();
+
 	auto* socket = static_cast<UdpSocketHandle*>(handle->data);
 
 	if (socket)
@@ -41,6 +45,8 @@ inline static void onRecv(
 
 inline static void onSend(uv_udp_send_t* req, int status)
 {
+	MS_TRACE();
+
 	auto* sendData = static_cast<UdpSocketHandle::UvSendData*>(req->data);
 	auto* handle   = req->handle;
 	auto* socket   = static_cast<UdpSocketHandle*>(handle->data);
@@ -57,6 +63,8 @@ inline static void onSend(uv_udp_send_t* req, int status)
 
 inline static void onCloseUdp(uv_handle_t* handle)
 {
+	MS_TRACE();
+
 	delete reinterpret_cast<uv_udp_t*>(handle);
 }
 
@@ -108,6 +116,8 @@ UdpSocketHandle::~UdpSocketHandle()
 
 void UdpSocketHandle::Dump(int indentation) const
 {
+	MS_TRACE();
+
 	MS_DUMP_CLEAN(indentation, "<UdpSocketHandle>");
 	MS_DUMP_CLEAN(indentation, "  local IP: %s", this->localIp.c_str());
 	MS_DUMP_CLEAN(indentation, "  local port: %" PRIu16, static_cast<uint16_t>(this->localPort));

package/worker/src/handles/UnixStreamSocketHandle.cpp

@@ -16,6 +16,8 @@
 
 inline static void onAlloc(uv_handle_t* handle, size_t suggestedSize, uv_buf_t* buf)
 {
+	MS_TRACE_STD();
+
 	auto* socket = static_cast<UnixStreamSocketHandle*>(handle->data);
 
 	if (socket)
@@ -26,6 +28,8 @@ inline static void onAlloc(uv_handle_t* handle, size_t suggestedSize, uv_buf_t*
 
 inline static void onRead(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf)
 {
+	MS_TRACE_STD();
+
 	auto* socket = static_cast<UnixStreamSocketHandle*>(handle->data);
 
 	if (socket)
@@ -36,6 +40,8 @@ inline static void onRead(uv_stream_t* handle, ssize_t nread, const uv_buf_t* bu
 
 inline static void onWrite(uv_write_t* req, int status)
 {
+	MS_TRACE_STD();
+
 	auto* writeData = static_cast<UnixStreamSocketHandle::UvWriteData*>(req->data);
 	auto* handle    = req->handle;
 	auto* socket    = static_cast<UnixStreamSocketHandle*>(handle->data);
@@ -54,11 +60,15 @@ inline static void onWrite(uv_write_t* req, int status)
 // ensuring that we call `delete xxx` with same type as `new xxx` before.
 inline static void onClosePipe(uv_handle_t* handle)
 {
+	MS_TRACE_STD();
+
 	delete reinterpret_cast<uv_pipe_t*>(handle);
 }
 
 inline static void onShutdown(uv_shutdown_t* req, int /*status*/)
 {
+	MS_TRACE_STD();
+
 	auto* handle = req->handle;
 
 	delete req;

package/worker/test/src/RTC/TestRateCalculator.cpp

@@ -14,9 +14,9 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 	};
 
 	auto validate =
-	  [](RTC::RateCalculator& rate, uint64_t timeBaseMs, std::vector<TestRateCalculatorData>& input)
+	  [](RTC::RateCalculator& rate, uint64_t timeBaseMs, const std::vector<TestRateCalculatorData>& input)
 	{
-		for (auto& item : input)
+		for (const auto& item : input)
 		{
 			rate.Update(item.size, timeBaseMs + item.offset);
 
@@ -26,7 +26,7 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 		// Repeat forcing nowMs to be 0.
 		rate.Reset();
 
-		for (auto& item : input)
+		for (const auto& item : input)
 		{
 			rate.Update(item.size, timeBaseMs + item.offset);
 
@@ -36,7 +36,7 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 		// Repeat forcing nowMs to be std::numeric_limits<uint64_t>::max() - 100.
 		rate.Reset();
 
-		for (auto& item : input)
+		for (const auto& item : input)
 		{
 			rate.Update(item.size, timeBaseMs + item.offset);
 
@@ -51,9 +51,9 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 		RTC::RateCalculator rate;
 
 		// clang-format off
-		std::vector<TestRateCalculatorData> input =
+		const std::vector<TestRateCalculatorData> input =
 		{
-			{ 0, 5, 40 }
+			{ .offset=0, .size=5, .rate=40 }
 		};
 		// clang-format on
 
@@ -65,12 +65,12 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 		RTC::RateCalculator rate;
 
 		// clang-format off
-		std::vector<TestRateCalculatorData> input =
+		const std::vector<TestRateCalculatorData> input =
 		{
-			{ 0,   5, 40  },
-			{ 100, 2, 56  },
-			{ 300, 2, 72  },
-			{ 999, 4, 104 }
+			{ .offset=0,   .size=5, .rate=40  },
+			{ .offset=100, .size=2, .rate=56  },
+			{ .offset=300, .size=2, .rate=72  },
+			{ .offset=999, .size=4, .rate=104 }
 		};
 		// clang-format on
 
@@ -82,11 +82,11 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 		RTC::RateCalculator rate(1000, 8000, 100);
 
 		// clang-format off
-		std::vector<TestRateCalculatorData> input =
+		const std::vector<TestRateCalculatorData> input =
 		{
-			{ 0,    5, 40 },
-			{ 1000, 5, 40 },
-			{ 2000, 5, 40 }
+			{ .offset=0,    .size=5, .rate=40 },
+			{ .offset=1000, .size=5, .rate=40 },
+			{ .offset=2000, .size=5, .rate=40 }
 		};
 		// clang-format on
 
@@ -98,13 +98,13 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 		RTC::RateCalculator rate(1000, 8000, 1000);
 
 		// clang-format off
-		std::vector<TestRateCalculatorData> input =
+		const std::vector<TestRateCalculatorData> input =
 		{
-			{ 0,    5, 40 },
-			{ 999,  2, 56 },
-			{ 1001, 1, 24 },
-			{ 1001, 1, 32 },
-			{ 2000, 1, 24 }
+			{ .offset=0,    .size=5, .rate=40 },
+			{ .offset=999,  .size=2, .rate=56 },
+			{ .offset=1001, .size=1, .rate=24 },
+			{ .offset=1001, .size=1, .rate=32 },
+			{ .offset=2000, .size=1, .rate=24 }
 		};
 		// clang-format on
 
@@ -118,15 +118,15 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 		RTC::RateCalculator rate(1000, 8000, 100);
 
 		// clang-format off
-		std::vector<TestRateCalculatorData> input =
+		const std::vector<TestRateCalculatorData> input =
 		{
-			{ 0,    5, 40 },
-			{ 999,  2, 56 },
-			{ 1001, 1, 24 }, // merged inside 999
-			{ 1001, 1, 32 }, // merged inside 999
-			{ 2000, 1, 8 } 	 // it will erase the item with timestamp=999,
-							 // removing also the next two samples.
-							 // The end estimation will include only the last sample.
+			{ .offset=0,    .size=5, .rate=40 },
+			{ .offset=999,  .size=2, .rate=56 },
+			{ .offset=1001, .size=1, .rate=24 }, // merged inside 999
+			{ .offset=1001, .size=1, .rate=32 }, // merged inside 999
+			{ .offset=2000, .size=1, .rate=8  }  // it will erase the item with
+			                // timestamp=999, removing also the next two samples. The
+			                // end estimation will include only the last sample.
 		};
 		// clang-format on
 
@@ -141,18 +141,18 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 		RTC::RateCalculator rate(1000, 8000, 5);
 
 		// clang-format off
-		std::vector<TestRateCalculatorData> input =
+		const std::vector<TestRateCalculatorData> input =
 		{
-			{ 1000, 1, 1*8 },
-			{ 1200, 1, 1*8 + 1*8 },
-			{ 1400, 1, 1*8 + 2*8 },
-			{ 1600, 1, 1*8 + 3*8 },
-			{ 1800, 1, 1*8 + 4*8 },
-			{ 2000, 1, 1*8 + (5-1)*8 }, // starts wrap here
-			{ 2200, 1, 1*8 + (6-2)*8 },
-			{ 2400, 1, 1*8 + (7-3)*8 },
-			{ 2600, 1, 1*8 + (8-4)*8 },
-			{ 2800, 1, 1*8 + (9-5)*8 },
+			{ .offset=1000, .size=1, .rate=1*8 },
+			{ .offset=1200, .size=1, .rate=(1*8) + (1*8) },
+			{ .offset=1400, .size=1, .rate=(1*8) + (2*8) },
+			{ .offset=1600, .size=1, .rate=(1*8) + (3*8) },
+			{ .offset=1800, .size=1, .rate=(1*8) + (4*8) },
+			{ .offset=2000, .size=1, .rate=(1*8) + ((5-1)*8) }, // starts wrap here
+			{ .offset=2200, .size=1, .rate=(1*8) + ((6-2)*8) },
+			{ .offset=2400, .size=1, .rate=(1*8) + ((7-3)*8) },
+			{ .offset=2600, .size=1, .rate=(1*8) + ((8-4)*8) },
+			{ .offset=2800, .size=1, .rate=(1*8) + ((9-5)*8) },
 		};
 		// clang-format on
 
@@ -167,12 +167,12 @@ SCENARIO("RateCalculator", "[rate-calculator]")
 		RTC::RateCalculator rate(1000, 8000, 3);
 
 		// clang-format off
-		std::vector<TestRateCalculatorData> input =
+		const std::vector<TestRateCalculatorData> input =
 		{
-			{ 0,   1, 8  },
-			{ 333, 1, 16  },
-			{ 666, 1, 24  },
-			{ 999, 1, 32 },
+			{ .offset=0,   .size=1, .rate=8  },
+			{ .offset=333, .size=1, .rate=16 },
+			{ .offset=666, .size=1, .rate=24 },
+			{ .offset=999, .size=1, .rate=32 },
   	};
 		// clang-format on
 

package/worker/test/src/RTC/TestSubchannelsCodec.cpp

@@ -22,7 +22,7 @@ SCENARIO("SubchannelsCodec", "[subchannels]")
 	};
 
 	SECTION(
-	  "EncodeSubchannels() encodes subchannels and requiredSubchannel and DecodeSubchannels() decodes them back")
+	  "EncodeSubchannels() encodes subchannels, requiredSubchannel and ignoredSubchannel and DecodeSubchannels() decodes them back")
 	{
 		const std::vector<uint8_t> originalPayload = { 0x01, 0x02, 0x03, 0x04 };
 
@@ -30,27 +30,32 @@ SCENARIO("SubchannelsCodec", "[subchannels]")
 
 		const std::vector<uint16_t> subchannels          = { 10, 20, 300 };
 		const std::optional<uint16_t> requiredSubchannel = 5;
+		const std::optional<uint16_t> ignoredSubchannel  = 6;
 
 		REQUIRE(
-		  RTC::SubchannelsCodec::EncodeSubchannels(message, subchannels, requiredSubchannel) == true);
+		  RTC::SubchannelsCodec::EncodeSubchannels(
+		    message, subchannels, requiredSubchannel, ignoredSubchannel) == true);
 
-		// 8 (Magic Token) + 2 (subchannelsCount) + 3 * 2 (subchannels) + 2 (requiredSubchannel).
-		REQUIRE(message.GetPayloadLength() == originalPayload.size() + 8 + 2 + (3 * 2) + 2);
+		// 8 (Magic Token) + 2 (subchannelsCount) + 3 * 2 (subchannels) +
+		// 2 (requiredSubchannel) + 2 (ignoredSubchannel).
+		REQUIRE(message.GetPayloadLength() == originalPayload.size() + 8 + 2 + (3 * 2) + 2 + 2);
 
 		std::vector<uint16_t> decodedSubchannels;
 		std::optional<uint16_t> decodedRequiredSubchannel;
+		std::optional<uint16_t> decodedIgnoredSubchannel;
 
 		REQUIRE(
 		  RTC::SubchannelsCodec::DecodeSubchannels(
-		    message, decodedSubchannels, decodedRequiredSubchannel) == true);
+		    message, decodedSubchannels, decodedRequiredSubchannel, decodedIgnoredSubchannel) == true);
 
 		REQUIRE(decodedSubchannels == subchannels);
 		REQUIRE(decodedRequiredSubchannel == requiredSubchannel);
+		REQUIRE(decodedIgnoredSubchannel == ignoredSubchannel);
 		// The header must have been removed, leaving the original payload.
 		REQUIRE(payloadToVector(message) == originalPayload);
 	}
 
-	SECTION("EncodeSubchannels() encodes subchannels without requiredSubchannel")
+	SECTION("EncodeSubchannels() encodes subchannels without requiredSubchannel nor ignoredSubchannel")
 	{
 		const std::vector<uint8_t> originalPayload = { 0xAA, 0xBB };
 
@@ -58,20 +63,24 @@ SCENARIO("SubchannelsCodec", "[subchannels]")
 
 		const std::vector<uint16_t> subchannels = { 1, 2 };
 
-		REQUIRE(RTC::SubchannelsCodec::EncodeSubchannels(message, subchannels, std::nullopt) == true);
+		REQUIRE(
+		  RTC::SubchannelsCodec::EncodeSubchannels(message, subchannels, std::nullopt, std::nullopt) ==
+		  true);
 
 		// 8 (Magic Token) + 2 (subchannelsCount) + 2 * 2 (subchannels).
 		REQUIRE(message.GetPayloadLength() == originalPayload.size() + 8 + 2 + (2 * 2));
 
 		std::vector<uint16_t> decodedSubchannels;
 		std::optional<uint16_t> decodedRequiredSubchannel;
+		std::optional<uint16_t> decodedIgnoredSubchannel;
 
 		REQUIRE(
 		  RTC::SubchannelsCodec::DecodeSubchannels(
-		    message, decodedSubchannels, decodedRequiredSubchannel) == true);
+		    message, decodedSubchannels, decodedRequiredSubchannel, decodedIgnoredSubchannel) == true);
 
 		REQUIRE(decodedSubchannels == subchannels);
 		REQUIRE(decodedRequiredSubchannel.has_value() == false);
+		REQUIRE(decodedIgnoredSubchannel.has_value() == false);
 		REQUIRE(payloadToVector(message) == originalPayload);
 	}
 
@@ -83,20 +92,82 @@ SCENARIO("SubchannelsCodec", "[subchannels]")
 
 		const std::optional<uint16_t> requiredSubchannel = 4321;
 
-		REQUIRE(RTC::SubchannelsCodec::EncodeSubchannels(message, {}, requiredSubchannel) == true);
+		REQUIRE(
+		  RTC::SubchannelsCodec::EncodeSubchannels(message, {}, requiredSubchannel, std::nullopt) == true);
 
 		// 8 (Magic Token) + 2 (subchannelsCount) + 2 (requiredSubchannel).
 		REQUIRE(message.GetPayloadLength() == originalPayload.size() + 8 + 2 + 2);
 
 		std::vector<uint16_t> decodedSubchannels;
 		std::optional<uint16_t> decodedRequiredSubchannel;
+		std::optional<uint16_t> decodedIgnoredSubchannel;
 
 		REQUIRE(
 		  RTC::SubchannelsCodec::DecodeSubchannels(
-		    message, decodedSubchannels, decodedRequiredSubchannel) == true);
+		    message, decodedSubchannels, decodedRequiredSubchannel, decodedIgnoredSubchannel) == true);
 
 		REQUIRE(decodedSubchannels.empty() == true);
 		REQUIRE(decodedRequiredSubchannel == requiredSubchannel);
+		REQUIRE(decodedIgnoredSubchannel.has_value() == false);
+		REQUIRE(payloadToVector(message) == originalPayload);
+	}
+
+	SECTION("EncodeSubchannels() encodes ignoredSubchannel without subchannels")
+	{
+		const std::vector<uint8_t> originalPayload = { 0xAA, 0xBB, 0xCC };
+
+		auto message = makeMessage(originalPayload);
+
+		const std::optional<uint16_t> ignoredSubchannel = 1234;
+
+		REQUIRE(
+		  RTC::SubchannelsCodec::EncodeSubchannels(message, {}, std::nullopt, ignoredSubchannel) == true);
+
+		// 8 (Magic Token) + 2 (subchannelsCount) + 2 (ignoredSubchannel).
+		REQUIRE(message.GetPayloadLength() == originalPayload.size() + 8 + 2 + 2);
+
+		std::vector<uint16_t> decodedSubchannels;
+		std::optional<uint16_t> decodedRequiredSubchannel;
+		std::optional<uint16_t> decodedIgnoredSubchannel;
+
+		REQUIRE(
+		  RTC::SubchannelsCodec::DecodeSubchannels(
+		    message, decodedSubchannels, decodedRequiredSubchannel, decodedIgnoredSubchannel) == true);
+
+		REQUIRE(decodedSubchannels.empty() == true);
+		REQUIRE(decodedRequiredSubchannel.has_value() == false);
+		REQUIRE(decodedIgnoredSubchannel == ignoredSubchannel);
+		REQUIRE(payloadToVector(message) == originalPayload);
+	}
+
+	SECTION("EncodeSubchannels() encodes subchannels and ignoredSubchannel without requiredSubchannel")
+	{
+		const std::vector<uint8_t> originalPayload = { 0x11 };
+
+		auto message = makeMessage(originalPayload);
+
+		const std::vector<uint16_t> subchannels         = { 100, 200 };
+		const std::optional<uint16_t> ignoredSubchannel = 200;
+
+		REQUIRE(
+		  RTC::SubchannelsCodec::EncodeSubchannels(
+		    message, subchannels, std::nullopt, ignoredSubchannel) == true);
+
+		// 8 (Magic Token) + 2 (subchannelsCount) + 2 * 2 (subchannels) +
+		// 2 (ignoredSubchannel).
+		REQUIRE(message.GetPayloadLength() == originalPayload.size() + 8 + 2 + (2 * 2) + 2);
+
+		std::vector<uint16_t> decodedSubchannels;
+		std::optional<uint16_t> decodedRequiredSubchannel;
+		std::optional<uint16_t> decodedIgnoredSubchannel;
+
+		REQUIRE(
+		  RTC::SubchannelsCodec::DecodeSubchannels(
+		    message, decodedSubchannels, decodedRequiredSubchannel, decodedIgnoredSubchannel) == true);
+
+		REQUIRE(decodedSubchannels == subchannels);
+		REQUIRE(decodedRequiredSubchannel.has_value() == false);
+		REQUIRE(decodedIgnoredSubchannel == ignoredSubchannel);
 		REQUIRE(payloadToVector(message) == originalPayload);
 	}
 
@@ -106,7 +177,8 @@ SCENARIO("SubchannelsCodec", "[subchannels]")
 
 		auto message = makeMessage(originalPayload);
 
-		REQUIRE(RTC::SubchannelsCodec::EncodeSubchannels(message, {}, std::nullopt) == false);
+		REQUIRE(
+		  RTC::SubchannelsCodec::EncodeSubchannels(message, {}, std::nullopt, std::nullopt) == false);
 
 		// The message must remain untouched.
 		REQUIRE(payloadToVector(message) == originalPayload);
@@ -120,13 +192,15 @@ SCENARIO("SubchannelsCodec", "[subchannels]")
 
 		std::vector<uint16_t> decodedSubchannels;
 		std::optional<uint16_t> decodedRequiredSubchannel;
+		std::optional<uint16_t> decodedIgnoredSubchannel;
 
 		REQUIRE(
 		  RTC::SubchannelsCodec::DecodeSubchannels(
-		    message, decodedSubchannels, decodedRequiredSubchannel) == false);
+		    message, decodedSubchannels, decodedRequiredSubchannel, decodedIgnoredSubchannel) == false);
 
 		REQUIRE(decodedSubchannels.empty() == true);
 		REQUIRE(decodedRequiredSubchannel.has_value() == false);
+		REQUIRE(decodedIgnoredSubchannel.has_value() == false);
 		REQUIRE(payloadToVector(message) == originalPayload);
 	}
 
@@ -138,21 +212,23 @@ SCENARIO("SubchannelsCodec", "[subchannels]")
 
 		std::vector<uint16_t> decodedSubchannels;
 		std::optional<uint16_t> decodedRequiredSubchannel;
+		std::optional<uint16_t> decodedIgnoredSubchannel;
 
 		REQUIRE(
 		  RTC::SubchannelsCodec::DecodeSubchannels(
-		    message, decodedSubchannels, decodedRequiredSubchannel) == false);
+		    message, decodedSubchannels, decodedRequiredSubchannel, decodedIgnoredSubchannel) == false);
 
 		REQUIRE(decodedSubchannels.empty() == true);
 		REQUIRE(decodedRequiredSubchannel.has_value() == false);
+		REQUIRE(decodedIgnoredSubchannel.has_value() == false);
 		REQUIRE(payloadToVector(message) == originalPayload);
 	}
 
 	SECTION(
 	  "DecodeSubchannels() ignores a truncated message that announces more subchannels than present")
 	{
-		// Craft a payload with the Magic Token (no requiredSubchannelFlag) that
-		// announces 3 subchannels but does not carry their bytes.
+		// Craft a payload with the Magic Token (no flags set) that announces 3
+		// subchannels but does not carry their bytes.
 		std::vector<uint8_t> originalPayload(10);
 
 		Utils::Byte::Set8Bytes(originalPayload.data(), 0, RTC::SubchannelsCodec::MagicToken);
@@ -162,13 +238,15 @@ SCENARIO("SubchannelsCodec", "[subchannels]")
 
 		std::vector<uint16_t> decodedSubchannels;
 		std::optional<uint16_t> decodedRequiredSubchannel;
+		std::optional<uint16_t> decodedIgnoredSubchannel;
 
 		REQUIRE(
 		  RTC::SubchannelsCodec::DecodeSubchannels(
-		    message, decodedSubchannels, decodedRequiredSubchannel) == false);
+		    message, decodedSubchannels, decodedRequiredSubchannel, decodedIgnoredSubchannel) == false);
 
 		REQUIRE(decodedSubchannels.empty() == true);
 		REQUIRE(decodedRequiredSubchannel.has_value() == false);
+		REQUIRE(decodedIgnoredSubchannel.has_value() == false);
 		REQUIRE(payloadToVector(message) == originalPayload);
 	}
 
@@ -190,13 +268,73 @@ SCENARIO("SubchannelsCodec", "[subchannels]")
 
 		std::vector<uint16_t> decodedSubchannels;
 		std::optional<uint16_t> decodedRequiredSubchannel;
+		std::optional<uint16_t> decodedIgnoredSubchannel;
+
+		REQUIRE(
+		  RTC::SubchannelsCodec::DecodeSubchannels(
+		    message, decodedSubchannels, decodedRequiredSubchannel, decodedIgnoredSubchannel) == false);
+
+		REQUIRE(decodedSubchannels.empty() == true);
+		REQUIRE(decodedRequiredSubchannel.has_value() == false);
+		REQUIRE(decodedIgnoredSubchannel.has_value() == false);
+		REQUIRE(payloadToVector(message) == originalPayload);
+	}
+
+	SECTION(
+	  "DecodeSubchannels() ignores a message whose ignoredSubchannelFlag is set but has no room for the ignoredSubchannel field")
+	{
+		// Craft a payload with the Magic Token and ignoredSubchannelFlag set,
+		// announcing 1 subchannel (present) but without the ignoredSubchannel bytes.
+		std::vector<uint8_t> originalPayload(12);
+
+		Utils::Byte::Set8Bytes(
+		  originalPayload.data(),
+		  0,
+		  RTC::SubchannelsCodec::MagicToken | RTC::SubchannelsCodec::IgnoredSubchannelFlagMask);
+		Utils::Byte::Set2Bytes(originalPayload.data(), 8, /*subchannelsCount*/ 1);
+		Utils::Byte::Set2Bytes(originalPayload.data(), 10, /*subchannel*/ 42);
+
+		auto message = makeMessage(originalPayload);
+
+		std::vector<uint16_t> decodedSubchannels;
+		std::optional<uint16_t> decodedRequiredSubchannel;
+		std::optional<uint16_t> decodedIgnoredSubchannel;
+
+		REQUIRE(
+		  RTC::SubchannelsCodec::DecodeSubchannels(
+		    message, decodedSubchannels, decodedRequiredSubchannel, decodedIgnoredSubchannel) == false);
+
+		REQUIRE(decodedSubchannels.empty() == true);
+		REQUIRE(decodedRequiredSubchannel.has_value() == false);
+		REQUIRE(decodedIgnoredSubchannel.has_value() == false);
+		REQUIRE(payloadToVector(message) == originalPayload);
+	}
+
+	SECTION(
+	  "DecodeSubchannels() ignores a message with both flags set but room for just one of the fields")
+	{
+		// Craft a payload with the Magic Token and both flags set, announcing no
+		// subchannels but carrying just 2 bytes after the header.
+		std::vector<uint8_t> originalPayload(12);
+
+		Utils::Byte::Set8Bytes(
+		  originalPayload.data(), 0, RTC::SubchannelsCodec::MagicToken | RTC::SubchannelsCodec::FlagsMask);
+		Utils::Byte::Set2Bytes(originalPayload.data(), 8, /*subchannelsCount*/ 0);
+		Utils::Byte::Set2Bytes(originalPayload.data(), 10, /*requiredSubchannel*/ 42);
+
+		auto message = makeMessage(originalPayload);
+
+		std::vector<uint16_t> decodedSubchannels;
+		std::optional<uint16_t> decodedRequiredSubchannel;
+		std::optional<uint16_t> decodedIgnoredSubchannel;
 
 		REQUIRE(
 		  RTC::SubchannelsCodec::DecodeSubchannels(
-		    message, decodedSubchannels, decodedRequiredSubchannel) == false);
+		    message, decodedSubchannels, decodedRequiredSubchannel, decodedIgnoredSubchannel) == false);
 
 		REQUIRE(decodedSubchannels.empty() == true);
 		REQUIRE(decodedRequiredSubchannel.has_value() == false);
+		REQUIRE(decodedIgnoredSubchannel.has_value() == false);
 		REQUIRE(payloadToVector(message) == originalPayload);
 	}
 
@@ -206,19 +344,23 @@ SCENARIO("SubchannelsCodec", "[subchannels]")
 
 		const std::vector<uint16_t> subchannels          = { 7 };
 		const std::optional<uint16_t> requiredSubchannel = 7;
+		const std::optional<uint16_t> ignoredSubchannel  = 8;
 
 		REQUIRE(
-		  RTC::SubchannelsCodec::EncodeSubchannels(message, subchannels, requiredSubchannel) == true);
+		  RTC::SubchannelsCodec::EncodeSubchannels(
+		    message, subchannels, requiredSubchannel, ignoredSubchannel) == true);
 
 		std::vector<uint16_t> decodedSubchannels;
 		std::optional<uint16_t> decodedRequiredSubchannel;
+		std::optional<uint16_t> decodedIgnoredSubchannel;
 
 		REQUIRE(
 		  RTC::SubchannelsCodec::DecodeSubchannels(
-		    message, decodedSubchannels, decodedRequiredSubchannel) == true);
+		    message, decodedSubchannels, decodedRequiredSubchannel, decodedIgnoredSubchannel) == true);
 
 		REQUIRE(decodedSubchannels == subchannels);
 		REQUIRE(decodedRequiredSubchannel == requiredSubchannel);
+		REQUIRE(decodedIgnoredSubchannel == ignoredSubchannel);
 		REQUIRE(message.GetPayloadLength() == 0);
 	}
 }